New Files

git-svn-id: http://framework.zend.com/svn/framework/standard/trunk@15610 44c647ce-9c0f-0410-b52a-842ac1e357ba

documentation/manual/es/module_specs/Zend_CodeGenerator-Reference.xml

@@ -0,0 +1,538 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.codegenerator.reference">
+    <title>Referencias de Zend_CodeGenerator</title>
+
+    <sect2 id="zend.codegenerator.reference.abstracts">
+        <title>Clases Abstractas e Interfaces</title>
+
+        <sect3 id="zend.codegenerator.reference.abstracts.abstract">
+            <title>Zend_CodeGenerator_Abstract</title>
+
+            <para>
+                La clase base desde la cual heredan todos las clases
+                CodeGenerator proporciona la funcionalidad mínima necesaria.
+                Su API es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+abstract class Zend_CodeGenerator_Abstract
+{
+    final public function __construct(Array $options = array())
+    public function setOptions(Array $options)
+    public function setSourceContent($sourceContent)
+    public function getSourceContent()
+    protected function _init()
+    protected function _prepare()
+    abstract public function generate();
+    final public function __toString()
+}
+]]></programlisting>
+
+            <para>
+                El constructor primero llama a <code>_init()</code>
+                (que se deja vacía para implementar extenciones a clases
+                concretas), se pasa entonces el parámetro <code>$options</code>
+                a <code>setOptions()</code>, y finalmente se llama a
+                <code>_prepare()</code> (nuevamente, a ser implementada por
+                extensión de una clase)
+            </para>
+
+            <para>
+                Al igual que la mayoría de las clases en Zend Framework,
+                <code>setOptions()</code> compara una opción clave con setters
+                existentes en la clase, y pasa el valor de ese método
+                si lo encuentra.
+            </para>
+
+            <para>
+                <code>__toString()</code> es marcado como final, y proxies a
+                <code>generate()</code>.
+            </para>
+
+            <para>
+                <code>setSourceContent()</code> y
+                <code>getSourceContent()</code> están destinados ya sea para
+                fijar el valor por defecto del contenido para el código a ser
+                generado, o para sustituir dicho contenido una vez que se
+                completen todas las tareas de generación.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.abstracts.php-abstract">
+            <title>Zend_CodeGenerator_Php_Abstract</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Abstract</classname> extiende
+                <classname>Zend_CodeGenerator_Abstract</classname>, y añade
+                algunas propiedades para localizar su contenido si es que ha
+                cambiado, así como el nivel de identación que debe aparecer
+                antes del contenido generado. Su API es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+abstract class Zend_CodeGenerator_Php_Abstract
+    extends Zend_CodeGenerator_Abstract
+{
+    public function setSourceDirty($isSourceDirty = true)
+    public function isSourceDirty()
+    public function setIndentation($indentation)
+    public function getIndentation()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.abstracts.php-member-abstract">
+            <title>Zend_CodeGenerator_Php_Member_Abstract</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname>
+                es una clase base para generar los miembros de clase --
+                propiedades y métodos -- y brinda accesos y mutadores para
+                establecer visibilidad; ya sea el miembro abstracto o no,
+                estático o definitivo; y el nombre del miembro.
+                Su API es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+abstract class Zend_CodeGenerator_Php_Member_Abstract
+    extends Zend_CodeGenerator_Php_Abstract
+{
+    public function setAbstract($isAbstract)
+    public function isAbstract()
+    public function setStatic($isStatic)
+    public function isStatic()
+    public function setVisibility($visibility)
+    public function getVisibility()
+    public function setName($name)
+    public function getName()
+}
+]]></programlisting>
+        </sect3>
+    </sect2>
+
+    <sect2 id="zend.codegenerator.reference.concrete">
+        <title>Clases Concretas de CodeGenerator</title>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-body">
+            <title>Zend_CodeGenerator_Php_Body</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Body</classname> se destina
+                para generar código procedural arbitrario para incluir dentro
+                de un archivo. Como tal, usted simplemente establece contenidos
+                para el objeto, y éste devolverá el contenido cuando usted
+                invoque a <code>generate()</code>.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Body extends Zend_CodeGenerator_Php_Abstract
+{
+    public function setContent($content)
+    public function getContent()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-class">
+            <title>Zend_CodeGenerator_Php_Class</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Class</classname> Está
+                destinado a generar clases PHP. La funcionalidad básica sólo
+                genera la clase PHP en si misma, así como opcionalmente el PHP
+                DocBlock. Las clases pueden implementarse o heredarse de otras
+                clases, y pueden ser marcadas como abstractas.
+                Utilizando otras clases generadoras de código, también puede
+                agregar constantes de clase, propiedades y métodos.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Class extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Class $reflectionClass
+    )
+    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
+    public function getDocblock()
+    public function setName($name)
+    public function getName()
+    public function setAbstract($isAbstract)
+    public function isAbstract()
+    public function setExtendedClass($extendedClass)
+    public function getExtendedClass()
+    public function setImplementedInterfaces(Array $implementedInterfaces)
+    public function getImplementedInterfaces()
+    public function setProperties(Array $properties)
+    public function setProperty($property)
+    public function getProperties()
+    public function getProperty($propertyName)
+    public function setMethods(Array $methods)
+    public function setMethod($method)
+    public function getMethods()
+    public function getMethod($methodName)
+    public function hasMethod($methodName)
+    public function isSourceDirty()
+    public function generate()
+}
+]]></programlisting>
+
+            <para>
+                El método <code>setProperty()</code> acepta un array de
+                información que puede ser utilizada para generar una instancia
+                <classname>Zend_CodeGenerator_Php_Property</classname> -- o
+                simplemente una instancia de
+                <classname>Zend_CodeGenerator_Php_Property</classname>.
+                Análogamente, <code>setMethod()</code> acepta o un array de
+                información para generar una instancia de
+                <classname>Zend_CodeGenerator_Php_Method</classname> o una
+                instancia concreta de esa clase.
+            </para>
+
+            <para>
+                Se debe observar que <code>setDocBlock()</code> espera una
+                instancia de
+                <classname>Zend_CodeGenerator_Php_DocBlock</classname>.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-docblock">
+            <title>Zend_CodeGenerator_Php_Docblock</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Docblock</classname> puede
+                ser utilizada para generar PHP docblocks arbitrarios,
+                incluidas todas las características estándar de docblock:
+                descripciones cortas y largas y además los tags de anotaciones.
+            </para>
+
+            <para>
+                Los tags de anotación pueden establecerse utilizando los métodos
+                <code>setTag()</code> y <code>setTags()</code>; cada una de
+                estas toman o un array describiendo el tag que puede ser pasado
+                al constructor
+                <classname>Zend_CodeGenerator_Php_Docblock_Tag</classname>, o
+                una instancia de esa clase.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Docblock extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Docblock $reflectionDocblock
+    )
+    public function setShortDescription($shortDescription)
+    public function getShortDescription()
+    public function setLongDescription($longDescription)
+    public function getLongDescription()
+    public function setTags(Array $tags)
+    public function setTag($tag)
+    public function getTags()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag">
+            <title>Zend_CodeGenerator_Php_Docblock_Tag</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Docblock_Tag</classname> está
+                destinado a crear tags de anotaciones arbitrarias
+                para su inclusión en PHP docblocks.
+                Se espera que los tags (etiquetas) contengan un nombre
+                (la porción que sigue inmediatamente después del símbolo '@')
+                y una descripción (todo lo que sigue después del nombre del
+                tag).
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Docblock_Tag
+    extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Docblock_Tag $reflectionTag
+    )
+    public function setName($name)
+    public function getName()
+    public function setDescription($description)
+    public function getDescription()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag-param">
+            <title>Zend_CodeGenerator_Php_DocBlock_Tag_Param</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_DocBlock_Tag_Param</classname>
+                es una versión especializada de
+                <classname>Zend_CodeGenerator_Php_DocBlock_Tag</classname>,
+                y representa un parámetro del método.
+                El nombre del tag es por lo tanto ("param"), pero debido
+                al formato de este tag de anotación, es necesaria información
+                adicional a fin de generarla: el nombre del parámetro y el tipo
+                de datos que representa.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Docblock_Tag_Param
+    extends Zend_CodeGenerator_Php_Docblock_Tag
+{
+    public static function fromReflection(
+        Zend_Reflection_Docblock_Tag $reflectionTagParam
+    )
+    public function setDatatype($datatype)
+    public function getDatatype()
+    public function setParamName($paramName)
+    public function getParamName()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-docblock-tag-return">
+            <title>Zend_CodeGenerator_Php_DocBlock_Tag_Return</title>
+
+            <para>
+                Al igual la variante del tag docblock,
+                <classname>Zend_CodeGenerator_Php_Docblock_Tab_Return</classname>
+                es una variante de un tag de anotación para representar el
+                valor de retorno del método. En este caso, el nombre del tag de
+                anotación es conocido ("return"), pero requiere un tipo de
+                retorno.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Docblock_Tag_Param
+    extends Zend_CodeGenerator_Php_Docblock_Tag
+{
+    public static function fromReflection(
+        Zend_Reflection_Docblock_Tag $reflectionTagReturn
+    )
+    public function setDatatype($datatype)
+    public function getDatatype()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-file">
+            <title>Zend_CodeGenerator_Php_File</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_File</classname> se utiliza
+                para generar el contenido íntegro de un archivo que contiene
+                código PHP. El archivo puede contener clases o código PHP
+                arbitrario, así como un archivo de nivel docblock si así lo
+                desea.
+            </para>
+
+            <para>
+                Cuando se agregan clases al archivo, necesitará pasar o un
+                array de información para pasar al constructor
+                <classname>Zend_CodeGenerator_Php_Class</classname>, o una
+                instancia de esa clase. De manera similar, con docblocks,
+                usted tendrá que pasar información para que lo consuma
+                el constructor
+                <classname>Zend_CodeGenerator_Php_Docblock</classname>
+                o una instancia de la clase.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_File extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflectedFilePath(
+        $filePath,
+        $usePreviousCodeGeneratorIfItExists = true,
+        $includeIfNotAlreadyIncluded = true)
+    public static function fromReflection(Zend_Reflection_File $reflectionFile)
+    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
+    public function getDocblock()
+    public function setRequiredFiles($requiredFiles)
+    public function getRequiredFiles()
+    public function setClasses(Array $classes)
+    public function getClass($name = null)
+    public function setClass($class)
+    public function setFilename($filename)
+    public function getFilename()
+    public function getClasses()
+    public function setBody($body)
+    public function getBody()
+    public function isSourceDirty()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-member-container">
+            <title>Zend_CodeGenerator_Php_Member_Container</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Member_Container</classname>
+                es usado internamente por
+                <classname>Zend_CodeGenerator_Php_Class</classname>
+                para seguir la pista de los los miembros de la clase  --
+                a propiedades y métodos por igual. Estos están indexados por
+                nombre, utilizando las instancias concretas de los miembros
+                como valores.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Member_Container extends ArrayObject
+{
+    public function __construct($type = self::TYPE_PROPERTY)
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-method">
+            <title>Zend_CodeGenerator_Php_Method</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Method</classname> describe
+                un método de clase, y puede generar tanto el código y el
+                docblock para el método. La visibilidad y condición estática,
+                abstracta, o se puede indicar como final, por su clase padre,
+                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname>.
+                Finalmente, pueden especificarse los parámetros y valor de
+                retorno para el método.
+            </para>
+
+            <para>
+                Pueden establecerse los parámetros usando
+                <code>setParameter()</code> o <code>setParameters()</code>.
+                En cada caso, un parámetro debe ser un array de información
+                para pasar al constructor
+                <classname>Zend_CodeGenerator_Php_Parameter</classname> o una
+                instancia de esa clase.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Method
+    extends Zend_CodeGenerator_Php_Member_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Method $reflectionMethod
+    )
+    public function setDocblock(Zend_CodeGenerator_Php_Docblock $docblock)
+    public function getDocblock()
+    public function setFinal($isFinal)
+    public function setParameters(Array $parameters)
+    public function setParameter($parameter)
+    public function getParameters()
+    public function setBody($body)
+    public function getBody()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-parameter">
+            <title>Zend_CodeGenerator_Php_Parameter</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Parameter</classname>
+                puede ser utilizada para especificar parámetros del método.
+                Cada parámetro puede tener una posición (si no están
+                especificados, se usarán en el orden que estén registrados en
+                el método), son oblogatorios un valor por defecto, un tipo de
+                datos y un nombre de parámetro.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Parameter extends Zend_CodeGenerator_Php_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Parameter $reflectionParameter
+    )
+    public function setType($type)
+    public function getType()
+    public function setName($name)
+    public function getName()
+    public function setDefaultValue($defaultValue)
+    public function getDefaultValue()
+    public function setPosition($position)
+    public function getPosition()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.codegenerator.reference.concrete.php-property">
+            <title>Zend_CodeGenerator_Php_Property</title>
+
+            <para>
+                <classname>Zend_CodeGenerator_Php_Property</classname> describe
+                una propiedad de clase, que puede ser tanto una constante o una
+                variable. En cada caso, la propiedad puede tener un valor
+                predeterminado asociado con ella. Además, la visibilidad de
+                las propiedades de la variable puede ser establecida por la
+                clase padre,
+                <classname>Zend_CodeGenerator_Php_Member_Abstract</classname>.
+            </para>
+
+            <para>
+                La API de la clase es la siguiente:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class Zend_CodeGenerator_Php_Property
+    extends Zend_CodeGenerator_Php_Member_Abstract
+{
+    public static function fromReflection(
+        Zend_Reflection_Property $reflectionProperty
+    )
+    public function setConst($const)
+    public function isConst()
+    public function setDefaultValue($defaultValue)
+    public function getDefaultValue()
+    public function generate()
+}
+]]></programlisting>
+        </sect3>
+    </sect2>
+</sect1>

documentation/manual/es/module_specs/Zend_Controller-ActionController.xml

@@ -0,0 +1,642 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- EN-Revision: 15103 -->
+<!-- Reviewed: no -->
+<sect1 id="zend.controller.action">
+    <title>Controladores de Acción</title>
+
+    <sect2 id="zend.controller.action.introduction">
+        <title>Introducción</title>
+        <para>
+            <classname>Zend_Controller_Action</classname> es una clase abstracta
+            que puede utilizar para implementar controladores de acción
+            (Action Controllers) para usar con el Front Controller al crear un
+            un sitio basado en el patrón Modelo-Vista-Controlador (MVC).
+        </para>
+
+        <para>
+            Para usar <classname>Zend_Controller_Action</classname>, necesitará
+            hacerla una subclase en sus clases actuales de controladores de
+            acción (o hacerla una subclase para crear su propia clase base de
+            acción de controladores).
+            La operación más elemental es hacerla una subclase, y crear métodos
+            de acción que corresponden a las diversas acciones que desee que el
+            contralor maneje para su sitio.
+            El manejo del ruteo y envío de
+            <classname>Zend_Controller</classname> descubrirá por sí mismo
+            cualquier método que termine en 'Action' en su clase, como posibles
+            acciones del controlador.
+        </para>
+
+        <para>
+            Por ejemplo, digamos que su clase se define como sigue:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function barAction()
+    {
+        // hacer algo
+    }
+
+    public function bazAction()
+    {
+        // hacer algo
+    }
+}
+]]></programlisting>
+
+        <para>
+            La clase de arriba <code>FooController</code> (el controlador
+            <code>foo</code>) define dos acciones, <code>bar</code> y
+            <code>baz</code>.
+        </para>
+
+        <para>
+            Se pueden lograr muchas cosas más, tales como personalizar
+            la inicialización de acciones, las acciones a llamar por defecto no
+            deberían especificar ninguna acción (o una acción inválida),
+            ganchos de pre y post despacho, y una variedad de métodos ayudantes.
+            Este capítulo sirve como panorama de la funcionalidad del
+            controlador de acciones.
+        </para>
+
+        <note>
+            <title>Comportamiento por Defecto</title>
+
+            <para>
+                Por defecto, el <link linkend="zend.controller.front">front
+                controller</link> habilita al ayudante de acción <link
+                linkend="zend.controller.actionhelpers.viewrenderer">ViewRenderer</link>.
+                Este ayudante toma a su cargo la inyección del objeto "view"
+                en el contralor, así como compatibilizar automáticamente las
+                vistas. Usted podrá desactivarlo dentro de su contralor de
+                acción por uno de los métodos siguientes:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function init()
+    {
+        // Local a este controlador únicamente; afecta a todas las acciones
+        // al cargarse en init:
+        $this->_helper->viewRenderer->setNoRender(true);
+
+        // Globalmente:
+        $this->_helper->removeHelper('viewRenderer');
+
+        // También globalmente, pero tendría que ser en conjunción con la
+        // versión local con el fin de propagarlo para este controlador:
+        Zend_Controller_Front::getInstance()
+            ->setParam('noViewRenderer', true);
+    }
+}
+]]></programlisting>
+
+            <para>
+                <code>initView()</code>, <code>getViewScript()</code>,
+                <code>render()</code>, y <code>renderScript()</code> cada
+                proxy al <code>ViewRenderer</code> a menos que el ayudante no
+                esté como ayudante intermediario o no se haya establecido el
+                flag de <code>noViewRenderer</code>.
+            </para>
+
+            <para>
+                También puede simplemente desactivarse para una prestación
+                individual ajustando el flag <code>noRender</code> de
+                <code>ViewRenderer</code>:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function barAction()
+    {
+        // deshabilitar el autorendering para esta acción solamente:
+        $this->_helper->viewRenderer->setNoRender();
+    }
+}
+]]></programlisting>
+
+            <para>
+                Las principales razones para desactivar
+                <code>ViewRenderer</code> son si usted simplemente no necesita
+                una objeto "view" o si no está mostrándolos via view scripts
+                (por ejemplo, cuando se utiliza un controlador de acción
+                para alimentar a los protocolos de un servicio web como SOAP,
+                XML-RPC, o REST). En muchos casos, nunca necesitará desactivar
+                a <code>ViewRenderer</code> globalmente, sólo selectivamente
+                dentro de los distintos controladores o acciones.
+            </para>
+        </note>
+    </sect2>
+
+    <sect2 id="zend.controller.action.initialization">
+        <title>Inicialización de Objectos</title>
+
+        <para>
+            Si bien siempre puede anular el contolador de acción del
+            constructor, no lo recomendamos.
+            <classname>Zend_Controller_Action::__construct()</classname>
+            realiza algunas tareas importantes, tales como registrar los
+            objetos de solicitud y respuesta, así como los argumentos de
+            cualquier invocación personalizada pasados desde el front
+            controller. Si debe anular el constructor, asegúrese de llamar a
+            <code>parent::__construct($request, $response, $invokeArgs)</code>.
+        </para>
+
+        <para>
+            La manera más apropiada de personalizar la instanciación es
+            utilizar el método <code>init()</code>, el cual es llamado como la
+            última tarea de <code>__construct()</code>.
+            Por ejemplo, si se quiere conectar a una base de datos en la
+            instanciación:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function init()
+    {
+        $this->db = Zend_Db::factory('Pdo_Mysql', array(
+            'host'     => 'myhost',
+            'username' => 'user',
+            'password' => 'XXXXXXX',
+            'dbname'   => 'website'
+        ));
+    }
+}
+]]></programlisting>
+    </sect2>
+
+    <sect2 id="zend.controller.action.prepostdispatch">
+        <title>Ganchos de Pre- and Post-Despacho</title>
+
+        <para>
+            <classname>Zend_Controller_Action</classname> especifica dos
+            métodos que pueden ser llamados para marcar una solicitud de acción,
+            <code>preDispatch()</code> y <code>postDispatch()</code>.
+            Estas pueden ser útiles de varias maneras: verificar la
+            autenticación y ACLs antes de ejecutar una acción (llamando a
+            <code>_forward()</code> en <code>preDispatch()</code>, se saltará
+            la acción), por ejemplo, o colocando contenido generado en una
+            plantilla general del sitio (<code>postDispatch()</code>).
+        </para>
+    </sect2>
+
+    <sect2 id="zend.controller.action.accessors">
+        <title>Accessors (Accededores)</title>
+
+        <para>
+            Con el objeto, se registran una serie de objetos y variables,
+            y cada uno tiene métodos de acceso.
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <emphasis>Objecto Requerimiento</emphasis>: <code>getRequest()</code>
+                puede ser utilizado para recuperar el objeto solicitud
+                utilizado para llamar a la acción.
+            </para></listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>Objecto Respuesta</emphasis>:
+                    <code>getResponse()</code> puede ser utilizado para
+                    recuperar el objeto respuesta agregando la respuesta final.
+                    Algunas llamadas típicas podrían ser:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+$this->getResponse()->setHeader('Content-Type', 'text/xml');
+$this->getResponse()->appendBody($content);
+]]></programlisting>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>Argumentos de Invocación</emphasis>: el front
+                    controller puede empujar parámetros al router, al
+                    despachador, y al controlador de acción. Para recuperarlos,
+                    use <code>getInvokeArg($key)</code>; por otra parte, se
+                    puede traer toda la lista utilizando
+                    <code>getInvokeArgs()</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>Parámetros de Requerimientos</emphasis>:
+                    La objeto solicitud agrega parámetros de solicitud,
+                    como cualquiera de los parámetros _GET o _POST,
+                    o parámetros del usuario especificados en la información
+                    del path de la URL. Para recuperarlos, use
+                    <code>_getParam($key)</code> o <code>_getAllParams()</code>.
+                    También se pueden establecer parámetros de solicitud usando
+                    <code>_setParam()</code>; lo que es útil cuando se reenvían
+                    a acciones adicionales.
+                </para>
+
+                <para>
+                    Para probar si un parámetro existe o no (muy útil para
+                    bifurcaciones lógicas), use <code>_hasParam($key)</code>.
+                </para>
+
+                <note>
+                    <para>
+                        <code>_getParam()</code> puede tomar opcionalmente un
+                        segundo argumento que contiene un valor por defecto a
+                        utilizar si el parámetro no está establecido o está
+                        vacío.  Usándolo elimina la necesidad de llamar
+                        previamente a <code>_hasParam()</code> para
+                        recuperar un valor:
+                    </para>
+
+                    <programlisting role="php"><![CDATA[
+// Usar por defecto el valor 1 si el id no está establecido
+$id = $this->_getParam('id', 1);
+
+// En lugar de:
+if ($this->_hasParam('id') {
+    $id = $this->_getParam('id');
+} else {
+    $id = 1;
+}
+]]></programlisting>
+                </note>
+            </listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.controller.action.viewintegration">
+        <title>Integración de Vistas</title>
+
+        <note id="zend.controller.action.viewintegration.viewrenderer">
+            <title>Integración de la Vista por Defecto via ViewRenderer</title>
+
+            <para>
+                El contenido de esta sección sólo es válida cuando usted tiene
+                explícitamente deshabilitado a
+                <link linkend="zend.controller.actionhelpers.viewrenderer">ViewRenderer</link>.
+                De lo contrario, puede saltarse esta sección.
+            </para>
+        </note>
+
+        <para>
+            <classname>Zend_Controller_Action</classname> proporciona un
+            mecanismo rudimentario y flexible para ver la integración.
+            Hay dos métodos para lograrlo, <code>initView()</code> y
+            <code>render()</code>; el anterior método <code>$view</code>
+            carga la propiedad pública, y este último muestra una vista en
+            base a la acción requerida actual, utilizando la jerarquía del
+            directorio para determinar el path del script.
+        </para>
+
+        <sect3 id="zend.controller.action.viewintegration.initview">
+            <title>Inicialización de la Vista</title>
+
+            <para>
+                <code>initView()</code> inicializa el objeto vista.
+                <code>render()</code> llama a <code>initView()</code>
+                con el fin de recuperar el objeto vista, pero puede ser
+                iniciada en cualquier momento; por defecto introduce
+                información a la propiedad de <code>$view</code> con un objeto
+                <classname>Zend_View</classname>, pero se puede usar cualquier
+                clase que implemente <classname>Zend_View_Interface</classname>.
+                Si <code>$view</code> ya ha sido inicializada, simplemente
+                devuelve esa propiedad.
+            </para>
+
+            <para>
+                La implementación por defecto hace la siguiente hipótesis de la
+                estructura del directorio:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+applicationOrModule/
+    controllers/
+        IndexController.php
+    views/
+        scripts/
+            index/
+                index.phtml
+        helpers/
+        filters/
+]]></programlisting>
+
+            <para>
+                En otras palabras, los scripts de vista se supone están en el
+                subdirectorio <code>views/scripts/</code>, y en el subdirectorio
+                <code>views</code> se supone que contiene funcionalidades
+                hermanas (ayudantes, filtros). Al determinar el nombre y el
+                path del script, el directorio <code>views/scripts/</code>
+                será utilizado como el path base, con directorios nombrados
+                después que los controladores individuales proporcionen una
+                jerarquía a los scripts de vista.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.controller.action.viewintegration.render">
+            <title>Suministrando las Vistas</title>
+
+            <para>
+                <code>render()</code> tiene la siguiente firma:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+string render(string $action = null,
+              string $name = null,
+              bool $noController = false);
+]]></programlisting>
+
+            <para>
+                <code>render()</code> suministra un script de vista.
+                Si no se pasan argumentos, se supone que el script requerido es
+                <code>[controller]/[action].phtml</code> (donde
+                <code>.phtml</code> es el valor de la propiedad
+                <code>$viewSuffix</code>).
+                Pasándole un valor a <code>$action</code> suministrará esa
+                plantilla en al subdirectorio <code>[controller]</code>. Para
+                anular el subdirectorio <code>[controller]</code> ponga un
+                valor verdadero en <code>$noController</code>.
+                Por último, las plantillas son suministradas en el objeto
+                respuesta; si desea suministrar a un determinado
+                <link linkend="zend.controller.response.namedsegments">
+                named segment</link> en el objeto respuesta, pase un valor a
+                <code>$name</code>.
+            </para>
+
+            <note><para>
+                    Dado que el controlador y los nombres de acción pueden
+                    contener caracteres delimitadores como '_', '.', y '-',
+                    <code>render()</code> los normaliza a '-' para determinar
+                    el nombre del script. Internamente, utiliza los
+                    delimitadores de palabra y de path del despachador para
+                    hacer esta normalización. Así, una solicitud a
+                    <code>/foo.bar/baz-bat</code> suministrará el script
+                    <code>foo-bar/baz-bat.phtml</code>.
+                    Si su método de acción contiene camelCasing, recuerde que
+                    esto se traducirá en palabras separadas por '-'
+                    al determinar el nombre del archivo del script de vista.
+            </para></note>
+
+            <para>
+                Algunos ejemplos:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class MyController extends Zend_Controller_Action
+{
+    public function fooAction()
+    {
+        // Suministra my/foo.phtml
+        $this->render();
+
+        // Suministra my/bar.phtml
+        $this->render('bar');
+
+        // Suministra baz.phtml
+        $this->render('baz', null, true);
+
+        // Suministra my/login.phtml al segmento 'form' del
+        // objeto respuesta
+        $this->render('login', 'form');
+
+        // Suministra site.phtml al segmento 'page' del objeto
+        // respuesta; no usa el subdirectorio 'my/'
+        $this->render('site', 'page', true);
+    }
+
+    public function bazBatAction()
+    {
+        // Suministra my/baz-bat.phtml
+        $this->render();
+    }
+}
+]]></programlisting>
+        </sect3>
+    </sect2>
+
+    <sect2 id="zend.controller.action.utilmethods">
+        <title>Métodos Utilitarios</title>
+
+        <para>
+            Además de los accesadores y de los métodos de integración de vistas,
+            <classname>Zend_Controller_Action</classname> tiene varios
+            métodos utilitarios para realizar tareas comunes dentro de sus
+            métodos de acción (o de pre-/post-despacho).
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>_forward($action, $controller = null, $module = null,
+                        array $params = null)</code>: realiza otra acción. Si es
+                    llamado en <code>preDispatch()</code>, la acción actualmente
+                    requerida se saltará en favor de la nueva.
+                    De lo contrario, después de procesar la acción actual,
+                    se ejecutará la acción solicitada en _forward().
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>_redirect($url, array $options =
+                        array())</code>: redireccionar a otro lugar.
+                        Este método toma una URL y un conjunto de opciones.
+                        Por defecto, realiza una redirección HTTP 302.
+                </para>
+
+                <para>
+                    Las opciones pueden incluir uno o más de los siguientes:
+                </para>
+
+                <itemizedlist>
+                    <listitem>
+                        <para>
+                            <emphasis>exit:</emphasis> ya sea para salir
+                            inmediatamente o no. Si así lo solicita, limpiamente
+                            cerrará cualquier sesión abierta y realizará
+                            la redirección.
+                        </para>
+
+                        <para>
+                            Puede configurar esta opción globalmente en el
+                            controlador utilizando el accesador
+                            <code>setRedirectExit()</code>.
+                        </para>
+                    </listitem>
+
+                    <listitem>
+                        <para>
+                            <emphasis>prependBase:</emphasis> ya sea
+                            anteponiendo o no la base URL registrada con el
+                            objeto solicitud a la URL provista.
+                        </para>
+
+                        <para>
+                            Puede configurar esta opción globalmente en el
+                            controlador utilizando el accesador
+                            <code>setRedirectPrependBase()</code>.
+                        </para>
+                    </listitem>
+
+                    <listitem>
+                        <para>
+                            <emphasis>code:</emphasis> qué código HTTP
+                            utilizar en la redirección. Por defecto,
+                            se utiliza un HTTP 302; se puede utilizar cualquier
+                            código entre 301 y 306.
+                        </para>
+
+                        <para>
+                            Puede configurar esta opción globalmente en el
+                            controlador utilizando el accesador
+                            <code>setRedirectCode()</code>.
+                        </para>
+                    </listitem>
+                </itemizedlist>
+            </listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.controller.action.subclassing">
+        <title>Controladores de Acción y haciendo Subclases</title>
+
+        <para>
+            Por diseño, <classname>Zend_Controller_Action</classname>
+            debe ser "subclaseada" a fin de crear un controlador de acción.
+            Como mínimo, necesitará definir los métodos de acción que podrá
+            llamar el controlador.
+        </para>
+
+        <para>
+            Además de crear una funcionalidad útil para su aplicaciones web,
+            también puede encontrar que está repitiendo demasiado los mismos
+            setups o métodos utilitarios en sus diferentes controladores;
+            si así fuera, creando una clase base común del controlador
+            que extienda <classname>Zend_Controller_Action</classname> puede
+            resolver esta redundacia.
+        </para>
+
+        <example id="zend.controller.action.subclassing.example-call">
+            <title>Manejando Acciones No Existentes</title>
+
+            <para>
+                Si hay una solicitud a un controlador que incluye un método de
+                acción no definido, se invocará a
+                <classname>Zend_Controller_Action::__call()</classname>.
+                <code>__call()</code> es, por supuesto, el método mágico de PHP
+                para la sobrecarga del método.
+            </para>
+
+            <para>
+                Por defecto, este método lanza un
+                <classname>Zend_Controller_Action_Exception</classname>
+                indicando que el método no se encuentró en el controlador.
+                Si el método requerido termina en 'Action', la suposición es
+                que una acción fue solicitada y no existe; tales errores
+                resultan en una excepción con un código 404.
+                Todos los demás métodos resultan en una excepción con un
+                código 500. Esto le permite diferenciar fácilmente entre una
+                página no encontrada y errores de aplicación con su
+                manejador de errores.
+            </para>
+
+            <para>
+                Usted debe anular esta funcionalidad si desea realizar otras
+                operaciones. Por ejemplo, si desea mostrar un mensaje de error,
+                usted podría escribir algo como esto:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class MyController extends Zend_Controller_Action
+{
+    public function __call($method, $args)
+    {
+        if ('Action' == substr($method, -6)) {
+            // Si no se encontró el método de la acción, suministrar la
+            // plantilla de error
+            return $this->render('error');
+        }
+
+        // todos los otros métodos lanzan una excepción
+        throw new Exception('Se ha llamado al método "'
+                            . $method
+                            . '" que es inválido',
+                            500);
+    }
+}
+]]></programlisting>
+
+            <para>
+                Otra posibilidad es que puede querer avanzar a un controlador
+                de página por defecto:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class MyController extends Zend_Controller_Action
+{
+    public function indexAction()
+    {
+        $this->render();
+    }
+
+    public function __call($method, $args)
+    {
+        if ('Action' == substr($method, -6)) {
+            // Si no se encontró el método de acción, avance a la
+            // acción index
+            return $this->_forward('index');
+        }
+
+        // todos los otros métodos lanzan una excepción
+        throw new Exception('Se ha llamado al método "'
+                            . $method
+                            . '" que es inválido',
+                            500);
+    }
+}
+]]></programlisting>
+        </example>
+
+        <para>
+            Además de sobrecargar <code>__call()</code>, cada uno de los
+            métodos gancho de inicialización, utilidad, accesador, vista,
+            y despacho mencionados anteriormente en este capítulo pueden ser
+            anulados a fin de personalizar sus controladores.
+            Como ejemplo, si está almacenando su objeto vista en un registro,
+            quizás desee modificar su método <code>initView()</code> con código
+            parecido al siguiente:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+abstract class My_Base_Controller extends Zend_Controller_Action
+{
+    public function initView()
+    {
+        if (null === $this->view) {
+            if (Zend_Registry::isRegistered('view')) {
+                $this->view = Zend_Registry::get('view');
+            } else {
+                $this->view = new Zend_View();
+                $this->view->setBasePath(dirname(__FILE__) . '/../views');
+            }
+        }
+
+        return $this->view;
+    }
+}
+]]></programlisting>
+
+        <para>
+            Es de esperar, que de la información en este capítulo, usted puede ver
+            la flexibilidad de este componente en particular y cómo puede darle
+            forma a su aplicaciones o a las necesidades de su sitio web.
+        </para>
+    </sect2>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-ActionHelpers-ActionStack.xml

@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect3 id="zend.controller.actionhelpers.actionstack">
+    <title>ActionStack</title>
+
+    <para>
+        El ayudante <code>ActionStack</code> le permite empujar requerimientos al
+        <link linkend="zend.controller.plugins.standard.actionstack">ActionStack</link>
+        plugin del front controller, el cual le ayuda efectivamente a crear
+        una cola de acciones a ejecutar durante la solicitud.
+        El ayudante le permite añadir acciones ya sea especificando nuevos
+        objetos solicitud o conjuntos acción/controlador/módulo.
+    </para>
+
+    <note>
+        <title>Invocando al Ayudante ActionStack Inicializa el Plugin de ActionStack</title>
+
+        <para>
+            Invocando al ayuudante <code>ActionStack</code> implicitamente
+            registra el plugin de <code>ActionStack</code> -- lo que significa
+            que no necesita registrar explícitamente el plugin de ActionStack
+            para utilizar esta funcionalidad.
+        </para>
+    </note>
+
+    <example id="zend.controller.actionhelpers.actionstack.simple">
+        <title>Agregando una Tarea Usando Nombres de Acción, Controllador y Módulo</title>
+
+        <para>
+            A menudo, es más sencillo simplemente especificar la acción, el
+            controlador y el módulo (y parámetros opcionales de requerimientos),
+            tal como cuando llama a
+            <classname>Zend_Controller_Action::_forward()</classname>:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function barAction()
+    {
+        // Agregar dos acciones a la pila (stack)
+        // Y llamar a  /foo/baz/bar/baz
+        // (FooController::bazAction() con el requrimiento var bar == baz)
+        $this->_helper->actionStack('baz',
+                                    'foo',
+                                    'default',
+                                    array('bar' => 'baz'));
+
+        // Agregar la llamada a /bar/bat
+        // (BarController::batAction())
+        $this->_helper->actionStack('bat', 'bar');
+    }
+}
+]]></programlisting>
+
+    </example>
+
+    <example id="zend.controller.actionhelpers.actionstack.simple2">
+        <title>Agregando una Tarea al Objeto Solicitud (Request)</title>
+
+        <para>
+            A veces la naturaleza OOP de un objeto solicitud tiene más sentido;
+            puede pasar también tal objeto al ayudante <code>ActionStack</code>.
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function barAction()
+    {
+        // Agregar dos acciones al stack
+        // Agregar la llamada a /foo/baz/bar/baz
+        // (FooController::bazAction() with request var bar == baz)
+        $request = clone $this->getRequest();
+        // No establezca controlador o módulo; use los valores actuales
+        $request->setActionName('baz')
+                ->setParams(array('bar' => 'baz'));
+        $this->_helper->actionStack($request);
+
+        // Agregar la llamada a /bar/bat
+        // (BarController::batAction())
+        $request = clone $this->getRequest();
+        // no establezca módulo; use el valor actual
+        $request->setActionName('bat')
+                ->setControllerName('bar');
+        $this->_helper->actionStack($request);
+    }
+}
+]]></programlisting>
+    </example>
+</sect3>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-ActionHelpers-AutoComplete.xml

@@ -0,0 +1,363 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect3 id="zend.controller.actionhelpers.autocomplete">
+    <title>AutoComplete</title>
+
+    <para>
+        Muchas bibliotecas de Javascript con AJAX ofrecen funcionalidad para
+        proporcionar autocompletado según la cual un selectlist de resultados
+        potencialmente concordantes se visualiza a medida que el usuario tipea.
+        El ayudante <code>AutoComplete</code> pretende simplificar el retorno
+        de respuestas aceptables a esos métodos.
+    </para>
+
+    <para>
+        Dado que no todas la bibliotecas JS implementan el autocompletado de
+        la misma manera, el ayudante <code>AutoComplete</code> ofrece algunas
+        funcionalidades abstractas de base necesarias para muchas bibliotecas,
+        e implementaciones concretas para distintas bibliotecas.
+        Los tipos de datos de retorno son generalmente o bien arrays de strings
+        JSON, array de arrays JSON (donde cada miembro del array está en un array
+        asociativo de metadatos utilizado para crear la selectlist), o HTML.
+    </para>
+
+    <para>
+        El uso básico para cada aplicación es el mismo:
+    </para>
+
+        <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function barAction()
+    {
+        // Ejecutar alguna lógica...
+
+        // Codificar y enviar la respuesta;
+        $this->_helper->autoCompleteDojo($data);
+
+        // O explicitamente:
+        $response = $this->_helper->autoCompleteDojo
+                                  ->sendAutoCompletion($data);
+
+        // O prepare simplemente la respuesta de autocompletado:
+        $response = $this->_helper->autoCompleteDojo
+                                  ->prepareAutoCompletion($data);
+    }
+}
+]]></programlisting>
+
+    <para>
+        Por defecto, el autocompletado hace lo siguiente:
+    </para>
+
+    <itemizedlist>
+        <listitem><para>
+                Desactiva esquemas y a ViewRenderer.
+        </para></listitem>
+
+        <listitem><para>
+                Establece las cabeceras apropiadas para la respuesta.
+        </para></listitem>
+
+        <listitem><para>
+                Establece el cuerpo de la respuesta con datos
+                codificados/formateados para autocompletar.
+        </para></listitem>
+
+        <listitem><para>
+                Envía la respuesta.
+        </para></listitem>
+    </itemizedlist>
+
+    <para>
+        Los métodos disponibles para el ayudante incluyen:
+    </para>
+
+    <itemizedlist>
+        <listitem><para>
+                <code>disableLayouts()</code> puede ser utilizada para
+                desactivar esquemas y a ViewRenderer. Típicamente, esto se
+                llama dentro de <code>prepareAutoCompletion()</code>.
+        </para></listitem>
+
+        <listitem><para>
+                <code>encodeJson($data, $keepLayouts = false)</code>
+                codificará datos a JSON, y opcionalmente habilitando o
+                deshabilitando esquemas. Típicamente, esto se llama dentro de
+                <code>prepareAutoCompletion()</code>.
+        </para></listitem>
+
+        <listitem><para>
+                <code>prepareAutoCompletion($data, $keepLayouts = false)</code>
+                se utiliza para preparar datos en el formato necesario de la
+                respuesta para la aplicación concreta, opcionalmente los
+                esquemas pueden habilitarse o deshabilitarse.
+                El valor de retorno variará dependiendo de la implementación.
+        </para></listitem>
+
+        <listitem><para>
+                <code>sendAutoCompletion($data, $keepLayouts = false)</code>
+                se utiliza para preparar datos en el formato necesario de la
+                respuesta para la aplicación concreta. Esta llama a
+                <code>prepareAutoCompletion()</code>, y entonces envía la
+                respuesta.
+        </para></listitem>
+
+        <listitem><para>
+                <code>direct($data, $sendNow = true, $keepLayouts =
+                    false)</code> se utiliza cuando se llama al ayudante como
+                    un método del ayudante intermediario. El flag
+                    <code>$sendNow</code> se utiliza para determinar si se debe
+                    llamar a <code>sendAutoCompletion()</code> o a
+                    <code>prepareAutoCompletion()</code>, respectivamente.
+        </para></listitem>
+    </itemizedlist>
+
+    <para>
+        Actualmente, <code>AutoComplete</code> soporta las bibliotecas AJAX de
+        Dojo y Scriptaculous.
+    </para>
+
+    <sect4 id="zend.controller.actionhelpers.autocomplete.dojo">
+        <title>AutoCompletado con Dojo</title>
+
+        <para>
+            Dojo no tiene un widget de autocompletado per se, pero tiene dos
+            widgets que pueden ejecutar AutoCompletado: ComboBox y
+            FilteringSelect. En ambos casos, necesitan de un almacén de datos
+            que implemente QueryReadStore; para obtener más información sobre
+            estos temas, ver la documentación en
+            <ulink url="http://dojotoolkit.org/book/dojo-book-0-9/part-3-programmatic-dijit-and-dojo/data-retrieval-dojo-data-0">dojo.data</ulink>
+        </para>
+
+        <para>
+            En Zend Framework, puede pasar un simple array indexado al ayudante
+            AutoCompleteDojo, y este regresará una adecuada respuesta JSON
+            para su uso como almacenamiento:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+// dentro del controlador de acción:
+$this->_helper->autoCompleteDojo($data);
+]]></programlisting>
+
+        <example id="zend.controller.actionhelpers.autocomplete.dojo.example1">
+            <title>AutoCompletion con Dojo Usando Zend MVC</title>
+
+            <para>
+                AutoCompletion con Dojo via Zend MVC requiere varias cosas:
+                generar un objeto form para el ComboBox en el que usted quiere
+                AutoCompletado, un controlador de acción para prestar servicio
+                a los resultados de AutoCompletion, creando un QueryReadStore
+                personalizado para conectar a la acción AutoCompletion,
+                y la generación del Javascript a utilizar en la inicializción
+                de AutoCompletion del lado del servidor.
+            </para>
+
+            <para>
+                En primer lugar, veamos el Javascript necesario. Dojo ofrece
+                un marco completo para crear Javascript OOP, tal como lo hace
+                Zend Framework para PHP. Parte de eso es la capacidad de
+                crear pseudo-namespaces utilizando la jerarquía de directorios.
+                Crearemos un directorio 'custom' en el mismo nivel en el cual
+                el directorio de Dojo forma parte de la distribución Dojo.
+                Dentro del directorio, crearemos un archivo Javascript,
+                TestNameReadStore.js, con el siguiente contenido:
+            </para>
+
+            <programlisting role="javascript"><![CDATA[
+dojo.provide("custom.TestNameReadStore");
+dojo.declare("custom.TestNameReadStore", dojox.data.QueryReadStore, {
+    fetch:function (request) {
+        request.serverQuery = { test:request.query.name };
+        return this.inherited("fetch", arguments);
+    }
+});
+]]></programlisting>
+
+            <para>
+                Esta clase es simplemente una extensión del propio
+                QueryReadStore de Dojo, que es de por sí misma una clase
+                abstracta. Simplemente definimos un método por el cual
+                realizamos la solicitud, y se le asigna al elemento 'test'.
+            </para>
+
+            <para>
+                A continuación, vamos a crear el elemento form para el que
+                queremos AutoCompletion:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class TestController extends Zend_Controller_Action
+{
+    protected $_form;
+
+    public function getForm()
+    {
+        if (null === $this->_form) {
+            $this->_form = new Zend_Form();
+            $this->_form->setMethod('get')
+                ->setAction(
+                    $this->getRequest()->getBaseUrl() . '/test/process'
+                )
+                ->addElements(array(
+                    'test' => array('type' => 'text', 'options' => array(
+                        'filters'        => array('StringTrim'),
+                        'dojoType'       => array('dijit.form.ComboBox'),
+                        'store'          => 'testStore',
+                        'autoComplete'   => 'false',
+                        'hasDownArrow'   => 'true',
+                        'label' => 'Your input:',
+                    )),
+                    'go' => array('type' => 'submit',
+                                  'options' => array('label' => 'Go!'))
+                ));
+        }
+        return $this->_form;
+    }
+}
+]]></programlisting>
+
+            <para>
+                Aquí, estamos simplemente creando un formulario con los métodos
+                'test' y 'go'. El método 'test' agrega varios atributos
+                especiales específicos de Dojo: dojoType, store, autoComplete
+                y hasDownArrow. El dojoType es utilizado para indicar que
+                estamos creando un ComboBox, y que vamos a vincularlo
+                a un almacén de datos (clave 'store') de 'testStore'
+                -- veremos más de esto más adelante.
+                Especificando 'autoComplete' como falso se le dice a Dojo que
+                no seleccione automáticamente el primer acierto, sino mostrar
+                una lista de aciertos. Por último, 'hasDownArrow' crea una
+                flecha abajo similar a un select box para que podamos
+                mostrar y ocultar los aciertos o concordancias.
+            </para>
+
+            <para>
+                Vamos a añadir un método para mostrar la forma, así como un
+                punto final para el procesamiento de AutoCompletion:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class TestController extends Zend_Controller_Action
+{
+    // ...
+
+    /**
+     * Página final
+     */
+    public function indexAction()
+    {
+        $this->view->form = $this->getForm();
+    }
+
+    public function autocompleteAction()
+    {
+        if ('ajax' != $this->_getParam('format', false)) {
+            return $this->_helper->redirector('index');
+        }
+        if ($this->getRequest()->isPost()) {
+            return $this->_helper->redirector('index');
+        }
+
+        $match = trim($this->getRequest()->getQuery('test', ''));
+
+        $matches = array();
+        foreach ($this->getData() as $datum) {
+            if (0 === strpos($datum, $match)) {
+                $matches[] = $datum;
+            }
+        }
+        $this->_helper->autoCompleteDojo($matches);
+    }
+}
+]]></programlisting>
+
+            <para>
+                En nuestro <code>autocompleteAction()</code> hacemos una serie
+                de cosas. En primer lugar, esperamos a asegurarnos de que
+                tengamos una petición post, y que existe un parámetro 'form'
+                establecido al valor 'ajax'; esto es simplemente para ayudar a
+                reducir preguntas espúreas a la acción.
+                A continuación, vamos a comprobar el parámetro 'test', y
+                compararlo contra nuestros datos. (Yo deliberadamente dejé de
+                lado la implementación de <code>getData()</code> aquí --
+                podría ser cualquier tipo de fuente de datos). Por último,
+                enviamos nuestros aciertos a nuestro ayudante AutoCompletion.
+            </para>
+
+            <para>
+                Ahora que tenemos todas las piezas en el backend, veamos lo que
+                necesitamos para entregar en nuestro script de vista para la
+                página final.
+                En primer lugar, necesitamos configurar nuestro data store,
+                luego hacer nuestro formulario, y finalmente garantizar que
+                las biblotecas Dojo apropiadas -- incluyendo que nuestro data
+                store personalizado -- estén cargadas.
+                Veamos el script de vista, el cual comenta los pasos:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+<?php // establecemos nuestro data store: ?>
+<div dojoType="custom.TestNameReadStore" jsId="testStore"
+    url="<?php echo $this->baseUrl() ?>/unit-test/autocomplete/format/ajax"
+    requestMethod="get"></div>
+
+<?php // mostramos nuestro form: ?>
+<?php echo $this->form ?>
+
+<?php // establecemos CSS relacionado con Dojo a cargar en HTML head: ?>
+<?php $this->headStyle()->captureStart() ?>
+@import "<?php echo $this->baseUrl()
+?>/javascript/dijit/themes/tundra/tundra.css";
+@import "<?php echo $this->baseUrl() ?>/javascript/dojo/resources/dojo.css";
+<?php $this->headStyle()->captureEnd() ?>
+
+<?php // setup de javascript para cargar en HTML head, incluyendo todas las
+   // bibliotecas Dojo requeridas: ?>
+<?php $this->headScript()
+        ->setAllowArbitraryAttributes(true)
+        ->appendFile($this->baseUrl() . '/javascript/dojo/dojo.js',
+            'text/javascript',
+            array('djConfig' => 'parseOnLoad: true'))
+        ->captureStart() ?>
+djConfig.usePlainJson=true;
+dojo.registerModulePath("custom","../custom");
+dojo.require("dojo.parser");
+dojo.require("dojox.data.QueryReadStore");
+dojo.require("dijit.form.ComboBox");
+dojo.require("custom.TestNameReadStore");
+<?php $this->headScript()->captureEnd()
+]]></programlisting>
+
+            <para>
+                Note que las llamadas a los ayudantes de vista como headStyle
+                y headScript; son ubicadores, que podemos suministrar a la
+                sección 'head' del HTML de nuestro script de vista.
+            </para>
+
+            <para>
+                Ahora tenemos todas las piezas para que el AutoCompletion
+                de Dojo pueda trabajar.
+            </para>
+        </example>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelpers.autocomplete.scriptaculous">
+        <title>AutoCompletion con Scriptaculous</title>
+        <para>
+            <ulink url="http://wiki.script.aculo.us/scriptaculous/show/Ajax.Autocompleter">Scriptaculous</ulink>
+            espera una respuesta HTML en un formato específico.
+        </para>
+
+        <para>
+            El ayudante para utilizar con esta biblioteca es
+            'AutoCompleteScriptaculous'. Simplemente proporcionarle un array de
+            datos, y el ayudante creará una respuesta HTML compatible con
+            Ajax.Autocompleter.
+        </para>
+    </sect4>
+</sect3>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-ActionHelpers-ContextSwitch.xml

@@ -0,0 +1,797 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect3 id="zend.controller.actionhelpers.contextswitch">
+    <title>ContextSwitch con AjaxContext</title>
+
+    <para>
+        El ayudante de acción <code>ContextSwitch</code> está destinado a
+        facilitar el regreso de respuestas de diferentes formatos de solicitud.
+        El ayudante <code>AjaxContext</code> es una versión especializada de
+        <code>ContextSwitch</code> que facilita el regreso de respuestas
+        a XmlHttpRequests.
+    </para>
+
+    <para>
+        Para habilitar alguno, usted debe proporcionar indicios en su
+        controlador de qué acciones pueden responder a que contextos.
+        Si una solicitud entrante indica un contexto válido para la acción
+        determinada, entonces el ayudante:
+    </para>
+
+    <itemizedlist>
+        <listitem><para>
+                Deshabilita los esquemas, si están habilitados.
+        </para></listitem>
+
+        <listitem><para>
+                Establecer un sufijo de vista alternativo, requiriendo de
+                manera efectiva un script de vista separado para el contexto.
+        </para></listitem>
+
+        <listitem><para>
+                Envía las cabeceras de respuesta apropiadas para el contexto
+                deseado.
+        </para></listitem>
+
+        <listitem><para>
+                Opcionalmente, llama a llamadas de retorno especifícas para
+                configurar el contexto y/o realizar post-procesamiento.
+        </para></listitem>
+    </itemizedlist>
+
+    <para>
+        Como ejemplo, tomemos el siguiente controlador:
+    </para>
+
+    <programlisting role="php"><![CDATA[
+class NewsController extends Zend_Controller_Action
+{
+    /**
+     * Página final; enviar a listAction()
+     */
+    public function indexAction()
+    {
+        $this->_forward('list');
+    }
+
+    /**
+     * Lista nuevos items
+     */
+    public function listAction()
+    {
+    }
+
+    /**
+     * Vista del nuevo item
+     */
+    public function viewAction()
+    {
+    }
+}
+]]></programlisting>
+
+    <para>
+        Digamos que queremos que <code>listAction()</code> también esté
+        disponible en un formato XML. En lugar de crear una acción diferente,
+        podemos indicarle que puede devolver una respuesta XML:
+    </para>
+
+    <programlisting role="php"><![CDATA[
+class NewsController extends Zend_Controller_Action
+{
+    public function init()
+    {
+        $contextSwitch = $this->_helper->getHelper('contextSwitch');
+        $contextSwitch->addActionContext('list', 'xml')
+                      ->initContext();
+    }
+
+    // ...
+}
+]]></programlisting>
+
+    <para>
+        Esto es lo que hará:
+    </para>
+
+    <itemizedlist>
+        <listitem><para>
+                Establecer la cabecera de respuesta 'Content-Type' a 'text/xml'.
+        </para></listitem>
+
+        <listitem><para>
+                Cambiar el sufijo de vista de 'xml.phtml' (o, si usa un sufifo
+                de vista alternativo, 'xml.[su sufijo]').
+        </para></listitem>
+    </itemizedlist>
+
+    <para>
+        Ahora, necesitará crear un nuevo script de vista, 'news/list.xml.phtml',
+        que creará y mostrará a XML.
+    </para>
+
+    <para>
+        Para determinar si una solicitud debe iniciar un cambio de contexto,
+        el ayudante comprueba si hay un token en el objeto solicitud.
+        Por defecto, busca el parámetro 'format', aunque esto puede ser
+        configurado. Esto significa que, en muchos casos, para provocar un
+        cambio de contexto, puede agregar un parámetro 'format' a su solicitud:
+    </para>
+
+    <itemizedlist>
+        <listitem><para>
+                Via parámetro URL: <code>/news/list/format/xml</code>
+                (recordar que el valor por defecto del esquema de ruteo permite
+                pares arbitrarios de clave/valor tras la acción).
+        </para></listitem>
+
+        <listitem><para>
+                Via parámetro GET: <code>/news/list?format=xml</code>
+        </para></listitem>
+    </itemizedlist>
+
+    <para>
+        <code>ContextSwitch</code> le permite especificar contextos arbitrarios,
+        incluso qué sufijo cambiará (si hay alguno), cualquier cabecera de
+        respuesta que deba ser enviada, y callbacks arbitrarios para la
+        inicialización y posterior procesamiento.
+    </para>
+
+    <sect4 id="zend.controller.actionhelpers.contextswitch.contexts">
+        <title>Contextos Disponibles por Defecto</title>
+
+        <para>
+            Por defecto, dos contextos están a disposición del ayudante
+            <code>ContextSwitch</code> : JSON y XML.
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <emphasis>JSON</emphasis>. El contexto JSON establece la
+                    cabecera de respuesta 'Content-Type' a 'application/json',
+                    y el sufijo del script de vista a 'json.phtml'.
+                </para>
+
+                <para>
+                    Sin embargo, por defecto, no es necesario un script de vista.
+                    Simplemente serializará todas las variables de la vista,
+                    y emitirá la respuesta JSON inmediatamente.
+                </para>
+
+                <para>
+                    Este comportamiento puede ser desactivado apagando la
+                    serialización auto-JSON:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+$this->_helper->contextSwitch()->setAutoJsonSerialization(false);
+]]></programlisting>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <emphasis>XML</emphasis>. El contexto XML establece la
+                    cabecera de respuesta 'Content-Type' a 'text/xml',
+                    y el sufijo del script de vista a 'xml.phtml'.
+                    Necesitará crear un script de vista nuevo para el contexto.
+                </para>
+            </listitem>
+        </itemizedlist>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelpers.contextswitch.custom">
+        <title>Creando Contextos Personalizados</title>
+
+        <para>
+            A veces, los contextos por defecto no son suficientes. Por ejemplo,
+            puede que desee devolver YAML, o PHP serializado, un RSS o ATOM
+            feed, etc. <code>ContextSwitch</code> le permite hacerlo.
+        </para>
+
+        <para>
+            La forma más fácil para añadir un nuevo contexto es a través del
+            método <code>addContext()</code>. Este método tiene dos argumentos,
+            el nombre del contexto, y un array de especificación.
+            La especificación debería incluir uno o más de los siguientes:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para><emphasis>suffix</emphasis>: el sufijo a anteponer al
+                sufijo de la vista por defecto tal como está registrado en
+                ViewRenderer.</para>
+            </listitem>
+
+            <listitem>
+                <para><emphasis>headers</emphasis>: un array de pares
+                cabecera/valor que desea enviar como parte de la respuesta.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para><emphasis>callbacks</emphasis>: un array que contiene una
+                o más de las claves 'init' o 'post', apuntando a callbacks PHP
+                válidos que pueden utilizarse para inicializar el contexto y
+                posterior procesamiento.</para>
+
+                <para>La inicialización de callbacks ocurre cuando el contexto
+                es detectado por <code>ContextSwitch</code>.
+                Usted puede usarlo para ejecutar una lógica arbitraria.
+                Por ejemplo, el contexto JSON utiliza un callback
+                para desactivar a ViewRenderer cuando está activada la
+                serialización auto-JSON.</para>
+
+                <para>El post procesamiento ocurre durante la rutina de la
+                acción <code>postDispatch()</code>, y puede ser utilizada
+                para ejecutar una lógica arbitraria. Como ejemplo, el contexto
+                JSON utiliza un callback para determinar si la serialización
+                auto-JSON está activada; si así fuera, serializa las variables
+                de la vista a JSON y envía la respuesta, pero si no,
+                re-habilita a ViewRenderer.</para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            Hay una variedad de métodos para interactuar con contextos:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+                <code>addContext($context, array $spec)</code>: agrega un nuevo
+                contexto. Lanza una excepción si el contexto ya existe.
+            </para></listitem>
+
+            <listitem><para>
+                <code>setContext($context, array $spec)</code>: añade un nuevo
+                contexto o sobrescribirá un contexto existente.
+                Usa la misma especificación que <code>addContext()</code>.
+            </para></listitem>
+
+            <listitem><para>
+                <code>addContexts(array $contexts)</code>: añade muchos
+                contextos de una vez. El array <code>$contexts</code> debería
+                ser un array de pares contexto/especificación.
+                Si alguno de los contextos ya existe, arrojará una excepción.
+            </para></listitem>
+
+            <listitem><para>
+                <code>setContexts(array $contexts)</code>: añade nuevos
+                contextos y sobreescribe los existentes. Usa la misma
+                especificación que <code>addContexts()</code>.
+             </para></listitem>
+
+            <listitem><para>
+                <code>hasContext($context)</code>: devuelve true si el contexto
+                existe, false de lo contrario.
+            </para></listitem>
+
+            <listitem><para> <code>getContext($context)</code>: recupera un
+            único contexto por su nombre. Devuelve un array siguiendo la
+            especificación usada en <code>addContext()</code>.
+            </para></listitem>
+
+            <listitem><para>
+                <code>getContexts()</code>: recupera todos los contextos.
+                Devuelve un array de pares contexto/especificación.
+            </para></listitem>
+
+            <listitem><para>
+                <code>removeContext($context)</code>: elimina un único contexto
+                por su nombre. Devuelve true si tiene éxito, false si el
+                contexto no fue encontrado.
+            </para></listitem>
+
+            <listitem><para>
+                <code>clearContexts()</code>: elimina todos los contextos.
+            </para></listitem>
+        </itemizedlist>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelpers.contextswitch.actions">
+        <title>Estableciendo los Contextos por Acción</title>
+
+        <para>
+            Hay dos mecanismos para establecer contextos disponibles.
+            Puede crear manualmente los arrays en su controlador, o utilizar
+            varios métodos en <code>ContextSwitch</code> para ensamblarlos.
+        </para>
+
+        <para>
+            El método principal para añadir relaciones acción/contexto es
+            <code>addActionContext()</code>. Se esperan dos argumentos,
+            la acción a la que el contexto se añade, y el nombre de un contexto
+            o un array de contextos. Como ejemplo, considere la siguiente
+            clase controlador:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function listAction()
+    {
+    }
+
+    public function viewAction()
+    {
+    }
+
+    public function commentsAction()
+    {
+    }
+
+    public function updateAction()
+    {
+    }
+}
+]]></programlisting>
+
+        <para>
+            Supongamos que queremos añadir un contexto XML a la acción 'list',
+            y contextos XML y JSON a la acción 'comments'.
+            Podríamos hacerlo en el método <code>init()</code>:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function init()
+    {
+        $this->_helper->contextSwitch()
+             ->addActionContext('list', 'xml')
+             ->addActionContext('comments', array('xml', 'json'))
+             ->initContext();
+    }
+}
+]]></programlisting>
+
+        <para>
+            Alternativamente, puede simplemente definir la propiedad del array
+            <code>$contexts</code>:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public $contexts = array(
+        'list'     => array('xml'),
+        'comments' => array('xml', 'json')
+    );
+
+    public function init()
+    {
+        $this->_helper->contextSwitch()->initContext();
+    }
+}
+]]></programlisting>
+
+        <para>
+            El anterior es el menos sobrecargado, pero también está expuesto a
+            posibles errores.
+        </para>
+
+        <para>
+            Los siguientes métodos pueden ser utilizados para construir los
+            mapeos del contexto:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>addActionContext($action, $context)</code>: marca uno
+                    o más contextos como disponibles para una acción.
+                    Si ya existen los mapeos, simplemente se añade a esos mapeos.
+                    <code>$context</code> puede ser un único contexto,
+                    o un array de contextos.
+                </para>
+
+                <para>
+                    Un valor de <code>true</code> para el contexto marcará
+                    todos los contextos como disponibles para la acción.
+                </para>
+
+                <para>
+                    Un valor vacío de $contexto desactivará todos los contextos
+                    para la acción determinada.
+                </para>
+            </listitem>
+
+            <listitem><para>
+                    <code>setActionContext($action, $context)</code>: marca uno
+                    o más contextos como disponibles para una acción.
+                    Si el mapeo ya existe, se reemplaza con los especificados.
+                    <code>$context</code> puede ser un único contexto,
+                    o un array de contextos.
+            </para></listitem>
+
+            <listitem><para>
+                    <code>addActionContexts(array $contexts)</code>: agrega
+                    varios pares acción/contexto de una vez.
+                    <code>$contexts</code> debe ser un array asociativo de
+                    pares acción/contexto. Le pasa la petición a
+                    <code>addActionContext()</code>, lo que significa que si
+                    los emparejamientos ya existen, se añade a ellos.
+            </para></listitem>
+
+            <listitem><para>
+                    <code>setActionContexts(array $contexts)</code>: actúa como
+                    <code>addActionContexts()</code>, pero sobreescribe
+                    pares de acción/contexto existentes.
+            </para></listitem>
+
+            <listitem><para>
+                    <code>hasActionContext($action, $context)</code>: determina
+                    si una acción particular tiene un contexto determinado.
+            </para></listitem>
+
+            <listitem><para>
+                    <code>getActionContexts($action = null)</code>: devuelve o
+                    todos los contextos para una acción determinada,
+                    o todos los pares de acción/contexto.
+            </para></listitem>
+
+            <listitem><para>
+                    <code>removeActionContext($action, $context)</code>: elimina
+                    uno o más contextos de una acción determinada.
+                    <code>$context</code> puede ser un único contexto o un
+                    array de contextos.
+            </para></listitem>
+
+            <listitem><para>
+                    <code>clearActionContexts($action = null)</code>: elimina
+                    todos los contextos de una acción determinada, o de todas
+                    las acciones con contextos.
+            </para></listitem>
+        </itemizedlist>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelpers.contextswitch.initcontext">
+        <title>Inicializando Conmutación de Contextos (Context Switching)</title>
+
+        <para>
+            Para inicializar la conmutación de contexto, necesita llamar a
+            <code>initContext()</code> en su controlador de acción:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class NewsController extends Zend_Controller_Action
+{
+    public function init()
+    {
+        $this->_helper->contextSwitch()->initContext();
+    }
+}
+]]></programlisting>
+
+        <para>
+            En algunos casos, puede querer forzar el contexto utilizado;
+            por ejemplo, puede que sólo quiera permitir el contexto XML si
+            la conmutación de contexto está activada. Puede hacerlo
+            pasando el contexto a <code>initContext()</code>:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$contextSwitch->initContext('xml');
+]]></programlisting>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelpers.contextswitch.misc">
+        <title>Funcionalidad Adicional</title>
+
+        <para>
+            Se pueden utilizar una variedad de métodos para alterar el
+            comportamiento del ayudante <code>ContextSwitch</code>.
+            Estos incluyen:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>setAutoJsonSerialization($flag)</code>: Por defecto,
+                    los contextos JSON serializarán cualquier variable de vista
+                    a notación JSON y lo devolverán como una respuesta.
+                    Si usted desea crear su propia respuesta, debe deshabilitar
+                    esta opción; esto debe hacerse antes de llamar a
+                    <code>initContext()</code>.
+                </para>
+
+                <programlisting role="php"><![CDATA[
+$contextSwitch->setAutoJsonSerialization(false);
+$contextSwitch->initContext();
+]]></programlisting>
+
+                <para>
+                    Puede recuperar el valor del flag con
+                    <code>getAutoJsonSerialization()</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setSuffix($context, $suffix,
+                        $prependViewRendererSuffix)</code>: Con este método,
+                        puede especificar un sufijo diferente para utilizarlo
+                        en un contexto determinado. El tercer argumento es
+                        utilizado para indicar si anteponer o no el actual
+                        sufijo de ViewRenderer con el nuevo sufijo; este flag
+                        está activado por defecto.
+                </para>
+
+                <para>
+                    Pasando un valor vacío para el sufijo hará que sólo el
+                    sufijo ViewRenderer será utilizado.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>addHeader($context, $header, $content)</code>: Añadir
+                    una cabecera de respuesta para un determinado contexto.
+                    <code>$header</code> es el nombre de la cabecera, y
+                    <code>$content</code> es el valor a pasar por esa cabecera.
+                </para>
+
+                <para>
+                    Cada contexto pueden tener múltiples cabeceras;
+                    <code>addHeader()</code> agrega cabeceras adicionales al
+                    stack de cabecera del contexto.
+                </para>
+
+                <para>
+                    Si el <code>$header</code> especificado ya existe para el
+                    contexto, arrojará una excepción.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setHeader($context, $header, $content)</code>:
+                    <code>setHeader()</code> actúa igual que
+                    <code>addHeader()</code>, excepto que le permite
+                    sobreescribir cabeceras del contexto actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>addHeaders($context, array $headers)</code>: Añade
+                    varias cabeceras de una vez a un determinado contexto.
+                    Delega a <code>addHeader()</code>, así que si la cabecera
+                    ya existe, arrojará una excepción. <code>$headers</code>
+                    es un array de pares cabecera/contexto.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setHeaders($context, array $headers.)</code>: como
+                    <code>addHeaders()</code>, excepto que lo delegua a
+                    <code>setHeader()</code>, permitiéndole sobreescribir las
+                    cabeceras existentes.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>getHeader($context, $header)</code>: recuperar el
+                    valor de una cabecera para un determinado contexto.
+                    Retorna null si no existe.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>removeHeader($context, $header)</code>: eliminar una
+                    única cabecera para un determinado contexto.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>clearHeaders($context, $header)</code>: eliminar
+                    todas las cabeceras para un determinado contexto.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setCallback($context, $trigger, $callback)</code>:
+                    establecer un callback en un determinado disparador para
+                    poner en marcha un determinado contexto. Los disparadores
+                    pueden ser 'init' o 'post' (indicando que se llamará a un
+                    callback para cada contexto de inicialización o
+                    postDispatch). <code>$callback</code> debe ser un callback
+                    válido de PHP.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setCallbacks($context, array $callbacks)</code>:
+                    establece varios callbacks para un determinado contexto.
+                    <code>$callbacks</code> deben ser pares de
+                    diparadores/callbacks. En realidad, la mayor cantidad de
+                    callbacks que pueden ser registrados son dos, uno para la
+                    inicialización y otro para el procesamiento posterior.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>getCallback($context, $trigger)</code>: recuperar un
+                    callback para un determinado disparador en un contexto dado.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>getCallbacks($context)</code>: recupera todos los
+                    callbacks para un determinado contexto. Devuelve un array
+                    de pares disparor/callback.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>removeCallback($context, $trigger)</code>: elimina un
+                    callback para un determinado disparador y contexto.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>clearCallbacks($context)</code>: elimina todos los
+                    callbacks para un determinado contexto.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setContextParam($name)</code>: establece el parámetro
+                    de petición para comprobar si un conmutador de contexto ha
+                    sido solicitado. El valor por defecto es 'format',
+                    pero este accededor puede ser utilizado para establecer un
+                    valor alternativo.
+                </para>
+
+                <para>
+                    <code>getContextParam()</code> puede ser utilizado para
+                    recuperar el valor actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setAutoDisableLayout($flag)</code>: Por defecto, los
+                    esquemas están deshabilitados cuando sucede una conmutación
+                    de contexto; esto es porque normalmente los esquemas sólo
+                    serán utilizados para devolver respuestas normales, y no
+                    tienen sentido en otros contextos.
+                    Sin embargo, si desea usar esquemas (tal vez puede tener un
+                    diseño para el nuevo contexto), puede cambiar este
+                    comportamiento pasando un valor falso a
+                    <code>setAutoDisableLayout()</code>. Usted debería hacer
+                    esto <emphasis>antes</emphasis> de llamar a
+                    <code>initContext()</code>.
+                </para>
+
+                <para>
+                    Para conseguir el valor de este flag, utilice el accededor
+                    <code>getAutoDisableLayout()</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>getCurrentContext()</code> Puede ser utilizado para
+                    determinar qué contexto fue detectado, si hay alguno.
+                    Este retorna null si no hubo conmutación de contexto,
+                    o si <code>initContext()</code> fue llamado antes de ser
+                    invocado.
+                </para>
+            </listitem>
+        </itemizedlist>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelpers.contextswitch.ajaxcontext">
+        <title>Funcionalidad de AjaxContext</title>
+
+        <para>
+            El ayudante <code>AjaxContext</code> extiende
+            <code>ContextSwitch</code>, así que toda de la funcionalidad
+            listada para <code>ContextSwitch</code> está disponible.
+            Hay algunas diferencias fundamentales, sin embargo.
+        </para>
+
+        <para>
+            En primer lugar, el controlador de acción utiliza una propiedad
+            diferente para determinar contextos, <code>$ajaxable</code>.
+            Esto es, que puede tener diferentes contextos utilizados para
+            AJAX versus peticiones normales HTTP.
+            Los diversos métodos <code>*ActionContext*()</code> de
+            <code>AjaxContext</code> le escribirán a esta propiedad.
+        </para>
+
+        <para>
+            En segundo lugar, sólo se disparará si se produjo un XmlHttpRequest,
+            según lo determinado por la solicitud del método del objeto
+            <code>isXmlHttpRequest()</code>.
+            Así, si se pasa el parámetro de contexto ('format') en la
+            solicitud, pero la solicitud no fue hecha como un XmlHttpRequest,
+            no se disparará ninguna conmutación de contexto.
+        </para>
+
+        <para>
+            En tercer lugar, <code>AjaxContext</code> agrega un contexto
+            adicional, HTML. En este contexto, se establece el sufijo a
+            'ajax.phtml' para diferenciar el contexto de una solicitud normal.
+            No se devuelven cabeceras adicionales.
+        </para>
+
+        <example id="zend.controller.actionhelpers.contextswitch.ajaxcontext.example">
+            <title>Permitiendo a las Acciones Responder a Requerimientos Ajax</title>
+
+            <para>
+                En el siguiente ejemplo, estamos permitiendo requerimientos a
+                las acciones 'view', 'form', y 'process' para responder a
+                peticiones AJAX. En los dos primeros casos, 'view' y 'form',
+                devolveremos fragmentos (snippets) de HTML con los cuales
+                actualizaremos la página; y en el último, devolveremos JSON.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class CommentController extends Zend_Controller_Action
+{
+    public function init()
+    {
+        $ajaxContext = $this->_helper->getHelper('AjaxContext');
+        $ajaxContext->addActionContext('view', 'html')
+                    ->addActionContext('form', 'html')
+                    ->addActionContext('process', 'json')
+                    ->initContext();
+    }
+
+    public function viewAction()
+    {
+        // Tirar para ver un único comentario.
+        // Cuando se detecta AjaxContext, utiliza el script de vista
+        // comment/view.ajax.phtml.
+    }
+
+    public function formAction()
+    {
+        // Mostrar el form "add new comment".
+        // Cuando se detecta AjaxContext, utiliza el script de vista
+        // comment/form.ajax.phtml.
+    }
+
+    public function processAction()
+    {
+        // Procesar un nuevo comentario
+        // Devolver los resultados como JSON; simplemente asignar los
+        // resultados como variables de la vista, y se devolverán como JSON.
+
+    }
+}
+]]></programlisting>
+
+            <para>
+                En el lado del cliente, su biblioteca AJAX simplemente pedirá
+                los parámetros finales '/comment/view', '/comment/form', y
+                '/comment/process', y pasar el parámetro 'format':
+                '/comment/view/format/html', '/comment/form/format/html',
+                '/comment/process/format/json'. (O puede pasar el parámetro via
+                string de consulta: e.g., "?format=json").
+            </para>
+
+            <para>
+                Asumiendo que su biblioteca pasa la cabecera
+                'X-Requested-With:XmlHttpRequest' entonces estas acciones
+                devolverán la respuesta en el formato apropiado.
+            </para>
+        </example>
+    </sect4>
+</sect3>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-ActionHelpers-FlashMessenger.xml

@@ -0,0 +1,69 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect3 id="zend.controller.actionhelpers.flashmessenger">
+    <title>FlashMessenger</title>
+
+    <sect4 id="zend.controller.actionhelper.flashmessenger.introduction">
+        <title>Introducción</title>
+        <para>
+            El ayudante <code>FlashMessenger</code> le permite pasar mensajes
+            que el usuario puede querer ver en la próxima solicitud.
+            Para lograrlo, <code>FlashMessenger</code> usa
+            <classname>Zend_Session_Namespace</classname> para almacenar los
+            mensajes para las futuras o próxima solicitud de recuperación.
+            Es una buena idea si planea utilizar
+            <classname>Zend_Session</classname> o
+            <classname>Zend_Session_Namespace</classname>, que inicializa con
+            <classname>Zend_Session::start()</classname> en su archivo
+            bootstrap. (Para más detalles de su uso vea la documentación en
+            <link linkend="zend.session.advanced_usage.starting_a_session">Zend_Session</link>).
+        </para>
+
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelper.flashmessenger.basicusage">
+        <title>Ejemplo Básico de Uso</title>
+        <para>
+            El ejemplo de uso de abajo muestra el uso del flash messenger en
+            su forma más elemental. Cuando se llama la acción
+            <code>/some/my</code>, añade el mensaje de flash "Record Saved!".
+            Una solicitud posterior a la acción
+            <code>/some/my-next-request</code> lo recuperará (y entonces
+            también lo suprimirá).
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class SomeController extends Zend_Controller_Action
+{
+    /**
+     * FlashMessenger
+     *
+     * @var Zend_Controller_Action_Helper_FlashMessenger
+     */
+    protected $_flashMessenger = null;
+
+    public function init()
+    {
+        $this->_flashMessenger =
+            $this->_helper->getHelper('FlashMessenger');
+        $this->initView();
+    }
+
+    public function myAction()
+    {
+        /**
+         * Método por defecto para obtener un instancia por demanda de
+         * Zend_Controller_Action_Helper_FlashMessenger
+         */
+        $this->_flashMessenger->addMessage('Record Saved!');
+    }
+
+    public function myNextRequestAction()
+    {
+        $this->view->messages = $this->_flashMessenger->getMessages();
+        $this->render();
+    }
+}
+]]></programlisting>
+    </sect4>
+</sect3>

documentation/manual/es/module_specs/Zend_Controller-ActionHelpers-Json.xml

@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect3 id="zend.controller.actionhelpers.json">
+    <title>JSON</title>
+
+    <para>
+        Las respuestas JSON se están convirtiendo en la respuesta de elección
+        cuando se trata de requerimientos AJAX que esperan recibir
+        respuestas datasets; en el lado del cliente, JSON puede ser inmediatamente parseado y
+        ejecutado rápidamente.
+    </para>
+
+    <para>
+        El ayudante de acción de JSON hace varias cosas:
+    </para>
+
+    <itemizedlist>
+        <listitem><para>
+                Deshabilita los layouts si estuvieran habilitados.
+        </para></listitem>
+
+        <listitem>
+            <para>
+                Opcionalmente, un array de opciones que pasar como segundo
+                argumento a <classname>Zend_Json::encode()</classname>.
+                Este array de opciones permite habilitar layouts y
+                codificación utilizando <classname>Zend_Json_Expr</classname>.
+             </para>
+
+            <programlisting role="php"><![CDATA[
+$this->_helper->json($data, array('enableJsonExprFinder' => true));
+]]></programlisting>
+        </listitem>
+
+        <listitem><para>
+                Desactiva la ViewRenderer si está actualmente habilitada.
+         </para></listitem>
+
+        <listitem><para>
+                Establece la cabecera de respuesta 'Content-Type' a 'application/json'.
+         </para></listitem>
+
+        <listitem><para>
+                Por defecto, devuelve inmediatamente la respuesta, sin esperar
+                a la acción para finalizar la ejecución.
+        </para></listitem>
+    </itemizedlist>
+
+    <para>
+        El uso es simple: o bien llamarlo como un método del ayudante,
+        o llamar a uno de los métodos <code>encodeJson()</code> o
+        <code>sendJson()</code>:
+    </para>
+
+    <programlisting role="php"><![CDATA[
+class FooController extends Zend_Controller_Action
+{
+    public function barAction()
+    {
+        // hacer algún procesamiento...
+        // Enviar la respuesta JSON:
+        $this->_helper->json($data);
+
+        // o...
+        $this->_helper->json->sendJson($data);
+
+        // o recuperar json:
+        $json = $this->_helper->json->encodeJson($data);
+    }
+}
+]]></programlisting>
+
+    <note>
+        <title>Conservando los Esquemas(Layouts)</title>
+
+        <para>
+            Si se tiene un esquema separado para respuestas de JSON --
+            quizás para envolver la respuesta de JSON en algún tipo de
+            contexto -- cada método en el ayudante JSON acepta un segundo
+            argumento opcional: un flag para activar o desactivar layouts.
+            Pasando un valor booleano <code>true</code> conservará los layouts
+            habilitados:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$this->_helper->json($data, true);
+]]></programlisting>
+
+        <para>
+            Opcionalmente, puede pasar un array como el segundo parámetro.
+            Este array puede contener una variedad de opciones, incluida la
+            opción <code>keepLayouts</code>:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$this->_helper->json($data, array('keepLayouts' => true);
+]]></programlisting>
+    </note>
+
+    <note>
+        <title>Habilitando la Codificación usando Zend_Json_Expr</title>
+
+        <para>
+            <classname>Zend_Json::encode()</classname> permite la codificación
+            de expresiones nativas de JSON utilizando objetos
+            <code>Zend_Json_Expr</code>. Esta opción está desactivada por
+            defecto. Para activar esta opción, pase un valor booleano
+            <code>true</code> a la opción <code>enableJsonExprFinder</code>:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$this->_helper->json($data, array('enableJsonExprFinder' => true);
+]]></programlisting>
+
+        <para>
+            Si desea hacer esto, <emphasis>debe</emphasis> pasar un array
+            como segundo argumento. Esto también le permite combinar otras
+            opciones, como la opción <code>keepLayouts</code>. Todas esas
+            opciones se pasan luego a <classname>Zend_Json::encode()</classname>.
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$this->_helper->json($data, array(
+    'enableJsonExprFinder' => true,
+    'keepLayouts'          => true,
+));
+]]></programlisting>
+    </note>
+</sect3>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-ActionHelpers-Redirector.xml

@@ -0,0 +1,332 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect3 id="zend.controller.actionhelpers.redirector">
+    <title>Redirector</title>
+
+    <sect4 id="zend.controller.actionhelper.redirector.introduction">
+        <title>Introducción</title>
+
+        <para>
+            El ayudante <code>Redirector</code> le permite utilizar un
+            objeto de redireccionamiento para cumplir con necesidades de su
+            aplicación para redireccionar a una nueva URL.
+            Ofrece numerosas ventajas sobre el método <code>_redirect()</code>,
+            tales como poder preconfigurar un comportamiento para todo el sitio
+            en el objeto redirector o usando el construido en
+            <code>gotoSimple($action, $controller, $module, $params)</code>,
+            interfaz similar a la de
+            <classname>Zend_Controller_Action::_forward()</classname>.
+        </para>
+
+        <para>
+            El <code>Redirector</code> tiene un número de métodos que pueden
+            utilizarse para afectar el comportamiento al redireccionar:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>setCode()</code> puede ser utilizado para establecer
+                    el código de respuesta HTTP que utilizar durante la
+                    redirección.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setExit()</code> puede usarse para forzar un
+                    <code>exit()</code> tras una redirección.
+                    Por defecto es verdadero (true).
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setGotoSimple()</code> puede ser utilizada para
+                    establecer la URL que usar por defecto si no se ha pasado
+                    ninguna a <code>gotoSimple()</code>.
+                    Utiliza la API de
+                    <classname>Zend_Controller_Action::_forward()</classname>:
+                    setGotoSimple($action, $controller = null, $module = null, array
+                    $params = array());
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setGotoRoute()</code> puede ser utilizada para
+                    establecer una URL basada en una ruta.
+                    Pasarla en un array de pares clave/valor y un nombre de ruta,
+                    y que ensamblarán la URL según la definición y el tipo de
+                    ruta.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setGotoUrl()</code> puede ser utilizada para
+                    establecer una URL por defecto si no se pasa ninguna a
+                    <code>gotoUrl()</code>. Acepta un solo string URL.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setPrependBase()</code> puede ser utilizada para
+                    anteponer la URL base del objeto solicitud a una URL
+                    especificada con
+                    <code>setGotoUrl()</code>, <code>gotoUrl()</code>, o
+                    <code>gotoUrlAndExit()</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setUseAbsoluteUri()</code> puede ser utilizada para
+                    forzar al <code>Redirector</code> a usar URIs absolutas
+                    cuando está redireccionando. Cuando se establece esta
+                    opción, se utiliza el valor de
+                    <code>$_SERVER['HTTP_HOST']</code>,
+                    <code>$_SERVER['SERVER_PORT']</code>, y
+                    <code>$_SERVER['HTTPS']</code>
+                    para formar una URI completa a la URL especificada por uno
+                    de los métodos de redirección. Esta opción está desactivada
+                    por defecto, pero podrá ser activada por defecto en
+                    versiones posteriores.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            Además, hay una variedad de métodos en el redireccionamiento para
+            realizar las redirecciones actuales:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>gotoSimple()</code> usa <code>setGotoSimple()</code>
+                    (<code>_forward()-tipo API</code>) para construir una URL
+                    y realizar un redireccionamiento.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>gotoRoute()</code> usa <code>setGotoRoute()</code>
+                    (<code>route-assembly</code>) para construir una URL
+                    y realizar un redireccionamiento.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>gotoUrl()</code> usa <code>setGotoUrl()</code>
+                    (<code>URL string</code>) para construir una URL
+                    y realizar un redireccionamiento.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            Por último, usted puede determinar la redirección actual de la URL
+            en cualquier momento usando <code>getRedirectUrl()</code>.
+        </para>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelper.redirector.basicusage">
+        <title>Ejemplos Básicos de Uso</title>
+
+        <example id="zend.controller.actionhelper.redirector.basicusage.example-1">
+            <title>Estableciendo Opciones</title>
+
+            <para>
+                Este ejemplo anula varias opciones, incluido el establecimiento del
+                código de estado HTTP para usar en la redirección ('303'),
+                no saliendo por defecto en la redirección, y definir una URL a
+                usar por defecto cuando se redireccione.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class SomeController extends Zend_Controller_Action
+{
+    /**
+     * Redirector - definido para completar el código
+     *
+     * @var Zend_Controller_Action_Helper_Redirector
+     */
+    protected $_redirector = null;
+
+    public function init()
+    {
+        $this->_redirector = $this->_helper->getHelper('Redirector');
+
+        // Establece las opciones por defecto del redirector
+        // Dado que el objeto es registrado en el ayudante, éstos pasan a
+        // ser relevantes para todas las acciones desde este punto en adelante
+
+        $this->_redirector->setCode(303)
+                          ->setExit(false)
+                          ->setGotoSimple("this-action",
+                                          "some-controller");
+    }
+
+    public function myAction()
+    {
+        /* hacer algunas cosas */
+
+        // Redireccionar a una URL previamente registrada,
+        // y forzar una salida cuando esté hecho:
+        $this->_redirector->redirectAndExit();
+        return; // nunca alcanzado
+    }
+}
+]]></programlisting>
+        </example>
+
+        <example id="zend.controller.actionhelper.redirector.basicusage.example-2">
+            <title>Usando Defaults</title>
+
+            <para>
+                Este ejemplo asume que se usan los valores predeterminados,
+                lo que significa que cualquier redirección resultará en un
+                <code>exit()</code> inmediato.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// EJEMPLO ALTERNATIVO
+class AlternativeController extends Zend_Controller_Action
+{
+    /**
+     * Redirector - definido para completar el código
+     *
+     * @var Zend_Controller_Action_Helper_Redirector
+     */
+    protected $_redirector = null;
+
+    public function init()
+    {
+        $this->_redirector = $this->_helper->getHelper('Redirector');
+    }
+
+    public function myAction()
+    {
+        /* hacer algunas cosas */
+
+        $this->_redirector
+            ->gotoUrl('/my-controller/my-action/param1/test/param2/test2');
+        return; // nunca alcanzado dado que por defecto es ir a URL y salir
+    }
+}
+]]></programlisting>
+        </example>
+
+        <example id="zend.controller.actionhelper.redirector.basicusage.example-3">
+            <title>Usando la API _forward() de goto()</title>
+
+            <para>
+                La API <code>gotoSimple()</code> imita a la de
+                <classname>Zend_Controller_Action::_forward()</classname>.
+                La diferencia principal es que construye una URL desde los
+                parámetros pasados, y utiliza el formato por defecto
+                <code>:module/:controller/:action/*</code> del enrutador
+                predeterminado. A continuación se redirecciona en lugar de
+                encadenar la acción.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class ForwardController extends Zend_Controller_Action
+{
+    /**
+     * Redirector - definido para completar el código
+     *
+     * @var Zend_Controller_Action_Helper_Redirector
+     */
+    protected $_redirector = null;
+
+    public function init()
+    {
+        $this->_redirector = $this->_helper->getHelper('Redirector');
+    }
+
+    public function myAction()
+    {
+        /* hacer algunas cosas */
+
+        // Redireccionar a 'my-action' de 'my-controller' en el módulo
+        // actual, usando los parámetros param1 => test y param2 => test2
+        $this->_redirector->gotoSimple('my-action',
+                                       'my-controller',
+                                       null,
+                                       array('param1' => 'test',
+                                             'param2' => 'test2'
+                                             )
+                                       );
+    }
+}
+]]></programlisting>
+        </example>
+
+        <example id="zend.controller.actionhelper.redirector.basicusage.example-4">
+            <title>Usando Ruta de Ensamblaje con gotoRoute()</title>
+
+            <para>
+                El siguiente ejemplo usa el método <code>assemble()</code> del
+                <link linkend="zend.controller.router">enrutador</link>
+                para crear una URL basada en un array asociativo de parámetros
+                pasados. Se supone que la siguiente ruta ha sido registrada:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+$route = new Zend_Controller_Router_Route(
+    'blog/:year/:month/:day/:id',
+    array('controller' => 'archive',
+          'module' => 'blog',
+          'action' => 'view')
+);
+$router->addRoute('blogArchive', $route);
+]]></programlisting>
+
+            <para>
+                Dado un array con el año fijado a 2006, mes a 4, día a 24,
+                e id a 42, entonces construye la siguiente URL
+                <code>/blog/2006/4/24/42</code>.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class BlogAdminController extends Zend_Controller_Action
+{
+    /**
+     * Redirector - definido para completar el código
+     *
+     * @var Zend_Controller_Action_Helper_Redirector
+     */
+    protected $_redirector = null;
+
+    public function init()
+    {
+        $this->_redirector = $this->_helper->getHelper('Redirector');
+    }
+
+    public function returnAction()
+    {
+        /* hacer algunas cosas */
+
+        // Redireccionar al archivo blog. Construir la siguiente URL:
+        // /blog/2006/4/24/42
+        $this->_redirector->gotoRoute(
+            array('year' => 2006,
+                  'month' => 4,
+                  'day' => 24,
+                  'id' => 42),
+            'blogArchive'
+        );
+    }
+}
+]]></programlisting>
+        </example>
+    </sect4>
+</sect3>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-ActionHelpers-ViewRenderer.xml

@@ -0,0 +1,921 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect3 id="zend.controller.actionhelpers.viewrenderer">
+    <title>ViewRenderer</title>
+
+    <sect4 id="zend.controller.actionhelper.viewrenderer.introduction">
+        <title>Introducción</title>
+
+        <para>
+            El ayudante <code>ViewRenderer</code> está diseñado para satisfacer
+            los siguientes objetivos:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    Eliminar la necesidad de instanciar objetos de vista dentro
+                    de los controladores; los objetos de vista quedarán
+                    registrados automáticamente con el contralor.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    Establece automáticamente el script de vista, el ayudante,
+                    y los paths de los filtros basados en el módulo actual.
+                    Asocia automáticamente el nombre del módulo actual como
+                    un prefijo de clase para las clases ayudante y filtro.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    Crea un objeto de vista, disponible globalmente para todos
+                    los controladores y acciones despachados.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    Permite al desarrollador establecer por defecto las
+                    opciones de renderizado para todos los controladores.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    Agrega la capacidad para renderizar automáticamente los
+                    scripts de vista sin ninguna intervención.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    Permite al desarrollador crear sus propias especificaciones
+                    para el path base de vistas y para el path de los scripts
+                    de vista.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <note>
+            <para>
+                Si realiza un <code>_forward()</code>, redirecciona, o
+                <code>render</code> manualmente, el autorendering no se llevará
+                a cabo, como está realizando cualquiera de estas acciones le
+                está diciendo al <code>ViewRenderer</code> que usted está
+                determinando su propia salida.
+            </para>
+        </note>
+
+        <note>
+            <para>
+                El <code>ViewRenderer</code> está habilitado por defecto.
+                Puede desactivarlo vía parámetro del front controller
+                <code>noViewRenderer</code>
+                (<code>$front->setParam('noViewRenderer', true)</code>) o
+                eliminando al ayudante del stack de ayudantes
+                (<classname>Zend_Controller_Action_HelperBroker::removeHelper('viewRenderer')</classname>).
+            </para>
+
+            <para>
+                Si desea modificar los settings del <code>ViewRenderer</code>
+                antes de despachar el front controller, puede hacerlo en una
+                de las dos maneras:
+            </para>
+
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        Instanciar y registrar su propio objeto
+                        <code>ViewRenderer</code> y pasarlo al ayudante:
+                    </para>
+
+                    <programlisting role="php"><![CDATA[
+$viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer();
+$viewRenderer->setView($view)
+             ->setViewSuffix('php');
+Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
+]]></programlisting>
+                </listitem>
+
+                <listitem>
+                    <para>
+                        Inicializar y/o recuperar un objeto
+                        <code>ViewRenderer</code> por demanda via el ayudante:
+                    </para>
+
+                    <programlisting role="php"><![CDATA[
+$viewRenderer =
+    Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
+$viewRenderer->setView($view)
+             ->setViewSuffix('php');
+]]></programlisting>
+                </listitem>
+            </itemizedlist>
+        </note>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelper.viewrenderer.api">
+        <title>API</title>
+
+        <para>
+            En su uso más básico, simplemente instancie a
+            <code>ViewRenderer</code> y páselo al ayudante de acciones.
+            La forma más fácil para instanciar y registrar de una sola vez es
+            utilizando el método del ayudante <code>getStaticHelper()</code>:
+          </para>
+
+        <programlisting role="php"><![CDATA[
+Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
+]]></programlisting>
+
+        <para>
+            La primera vez que se instancia un controlador de acción, se
+            disparará <code>ViewRenderer</code> para instanciar al objeto
+            vista. Cada vez que el controlador es instanciado, se llama al
+            método <code>init()</code> de <code>ViewRenderer</code>, que lo
+            llevará a establecer la propiedad del controlador de acción, y
+            llama a <code>addScriptPath()</code> con un path relativo al
+            módulo actual; este será llamado con un prefijo de clase nombrada
+            después del módulo actual, haciendo efectivamente el namespacing de
+            todas las clases de ayudantes y filtros que define para el módulo.
+        </para>
+
+        <para>
+            Cad vez que llama a <code>postDispatch()</code>, este llamará a
+            <code>render()</code> para la acción actual.
+        </para>
+
+        <para>
+            Como ejemplo, considere la siguiente clase:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+// Una clase controlador, módulo foo:
+class Foo_BarController extends Zend_Controller_Action
+{
+    // Render bar/index.phtml por defecto; no se requiere acción
+    public function indexAction()
+    {
+    }
+
+    // Render bar/populate.phtml con la variable 'foo' establecida a 'bar'.
+    // Dado que el objeto vista está definido en preDispatch(),
+    // ya está disponible.
+    public function populateAction()
+    {
+        $this->view->foo = 'bar';
+    }
+}
+
+...
+
+// en uno de sus scripts de vista:
+$this->foo(); // llama a Foo_View_Helper_Foo::foo()
+]]></programlisting>
+
+        <para>
+            El <code>ViewRenderer</code> también define una serie de accededores
+            para permitir establecer y recuperar opciones de vista:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>setView($view)</code> le permite establecer el objeto
+                    vista para <code>ViewRenderer</code>. Se vuelve como una
+                    propiedad de clase pública <code>$view</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setNeverRender($flag = true)</code> puede ser
+                    utilizado para activar o desactivar globalmente el
+                    autorendering, es decir, para todos los controladores.
+                    Si es verdadero, <code>postDispatch()</code> no llamará
+                    automáticamente a <code>render()</code> en el controlador
+                    actual. <code>getNeverRender()</code> recupera el valor
+                    actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setNoRender($flag = true)</code> puede ser utilizado
+                    para activar o desactivar el autorendering.
+                    Si es verdadero, <code>postDispatch()</code> no llamará
+                    automáticamente a <code>render()</code> en el controlador
+                    actual. Este ajuste se reseteará cada vez que se llame a
+                    <code>preDispatch()</code> (es decir, usted necesita
+                    establecer este flag para cada controlador para el cual
+                    no quiera que el autorenderering se ejecute).
+                    <code>getNoRender()</code> recupera el valor actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setNoController($flag = true)</code> pude ser usado
+                    para decirle a <code>render()</code> que no busque el
+                    script de acción en un subdirectorio nombrado después de
+                    que el controlador (que es el comportamiento por defecto)
+                    <code>getNoController()</code> recupere el valor actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setNeverController($flag = true)</code> es análogo
+                    a <code>setNoController()</code>, pero trabaja a un nivel
+                    global -- es decir, que no se reseteará por cada acción
+                    ejecutada. <code>getNeverController()</code> recupera el
+                    valor actual.
+                   </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setScriptAction($name)</code> puede ser utilizado para
+                    especificar el script de acción a renderizar.
+                    <code>$name</code> debe ser el nombre del script menos el
+                    sufijo del archivo (y sin el subdirectorio del controlador,
+                    a menos que <code>noController</code> se haya activado).
+                    Si no se ha especificado, busca un script de vista nombrado
+                    después de la acción en el objeto solicitud.
+                    <code>getScriptAction()</code> recupera el valor actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setResponseSegment($name)</code> puede ser utilizado
+                    para especificar qué segmento del objeto respuesta nombrado
+                    renderizar. Si no se especifica, se hace en el segmento por
+                    defecto. <code>getResponseSegment()</code> recupera el
+                    valor actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>initView($path, $prefix, $options)</code> puede ser
+                    llamado para especificar el path base de las vistas,
+                    prefijos de clase para scripts de ayudantes y filtros, y
+                    las opciones de <code>ViewRenderer</code>.
+                    Puede pasar cualquiera de los siguientes flags:
+                    <code>neverRender</code>, <code>noRender</code>,
+                    <code>noController</code>, <code>scriptAction</code>, y
+                    <code>responseSegment</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setRender($action = null, $name = null, $noController
+                        = false)</code> le permite establecer cualquier
+                    <code>scriptAction</code>, <code>responseSegment</code>, y
+                    <code>noController</code> en un pase. <code>direct()</code>
+                    es un alias a este método, permitiéndole llamar a este
+                    método fácilmente dede su controlador:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+// Render 'foo' en lugar del script de acción actual
+$this->_helper->viewRenderer('foo');
+
+// render form.phtml al segmento de respuesta de 'html', sin usar un
+// subdirectorio de scripts de controladores de acción:
+$this->_helper->viewRenderer('form', 'html', true);
+]]></programlisting>
+
+                <note><para>
+                        <code>setRender()</code> y <code>direct()</code>
+                        realmente no renderiza el script de vista, sino que
+                        establece indicaciones que <code>postDispatch()</code>
+                        y <code>render()</code> utlizarán para renderizar la
+                        vista.
+                 </para></note>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            El constructor le permite opcionalmente pasar el objeto vista y las
+            opciones de <code>ViewRenderer</code>; acepta los mismos flags que
+            <code>initView()</code>:
+         </para>
+
+        <programlisting role="php"><![CDATA[
+$view    = new Zend_View(array('encoding' => 'UTF-8'));
+$options = array('noController' => true, 'neverRender' => true);
+$viewRenderer =
+    new Zend_Controller_Action_Helper_ViewRenderer($view, $options);
+]]></programlisting>
+
+        <para>
+            Hay varios métodos adicionales para personalizar especificaciones
+            del path, usados para determinar el path base del script de vista
+            para añadir al objeto vista, y el path del script de vista a usar
+            cuando esté autodeterminando el script de vista a renderizar.
+            Cada uno de estos métodos toma uno o más de los siguientes
+            localizadores:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>:moduleDir</code> hace referencia a la actual
+                    directorio base del módulo(por convención, el directorio
+                    padre del directorio del módulo controlador).
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>:module</code> hace referencia al nombre del módulo
+                    actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>:controller</code> hace referencia al nombre del
+                    controlador actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>:action</code> hace referencia al nombre de la
+                    acción actual.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>:suffix</code> hace referencia al sufijo del script
+                    de vista (que puede ser definido via
+                    <code>setViewSuffix()</code>).
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            Los métodos para controlar las especificaciones del path son:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>setViewBasePathSpec($spec)</code> le permite cambiar
+                    la especificación del path utilizada para determinar el
+                    path base para añadir al objeto vista.
+                    La especificación por defecto es <code>:moduleDir/views</code>.
+                    Puede recuperar la especificación actual en cualquier
+                    momento usando <code>getViewBasePathSpec()</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setViewScriptPathSpec($spec)</code> le permite
+                    cambiar el path de la especificación utilizada para
+                    determinar el path a un script de vista individual
+                    (menos el path de la base del script de vista).
+                    La especificación por defecto es
+                    <code>:controller/:action.:suffix</code>.
+                    Puede recuperar la especificación actual en cualquier
+                    momento usando
+                    <code>getViewScriptPathSpec()</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setViewScriptPathNoControllerSpec($spec)</code>
+                    le permite cambiar el path de la especificación utilizado
+                    para determinar el path a un script de vista individual
+                    cuando <code>noController</code> está activado
+                    (menos el path base del script de vista). La especificación
+                    por defecto es <code>:action.:suffix</code>. Puede
+                    recuperar la especificación actual en cualquier momento
+                    usando <code>getViewScriptPathNoControllerSpec()</code>.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            Para un control más refinado sobre el path de especificaciones,
+            puede usar
+            <link linkend="zend.filter.inflector">Zend_Filter_Inflector</link>.
+            Bajo el capó, <code>ViewRenderer</code> ya usa un inflector para
+            realizar mapeos del path. Para interactuar con el inflector
+            -- ya sea para establecerlo para uso propio, o para modificar el
+            inflector por defecto, se pueden utilizar los siguientes
+            métodos:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>getInflector()</code> recupera el inflector.
+                    Si no existe todavía en <code>ViewRenderer</code>, se crea
+                    uno utilizando las reglas predeterminadas.
+                </para>
+
+                <para>
+                    Por defecto, utiliza reglas de referencias estáticas para el
+                    sufijo y directorio de módulos, así como una meta estática;
+                    esto permite que diversas propiedades de
+                    <code>ViewRenderer</code> tengan la capacidad de
+                    modificar dinámicamente al inflector.
+                </para>
+            </listitem>
+
+            <listitem><para>
+                    <code>setInflector($inflector, $reference)</code> permite
+                    establecer un inflector personalizado para usar con
+                    <code>ViewRenderer</code>. Si <code>$reference</code> es
+                    verdadero, establecerá el sufijo y directorio de módulos
+                    como referencias estáticas a las propiedades de
+                    <code>ViewRenderer</code>, así como al objetivo.
+            </para></listitem>
+        </itemizedlist>
+
+        <note>
+            <title>Convenciones por Defecto para Lookup</title>
+
+            <para>
+                El <code>ViewRenderer</code> hace algún tipo de normalización
+                del path para facilitar la búsqueda de los scripts de vista.
+                Las reglas predeterminadas son los siguientes:
+            </para>
+
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        <code>:module</code>: MixedCase y camelCasedWords
+                        están separados por guiones, y el string completo se
+                        convierte a minúsculas.
+                        Por ejemplo: "FooBarBaz" pasa a ser "foo-bar-baz".
+                    </para>
+
+                    <para>
+                        Internamente, el inflector utiliza los filtros
+                        <classname>Zend_Filter_Word_CamelCaseToDash</classname>
+                        y <classname>Zend_Filter_StringToLower</classname>.
+                    </para>
+                </listitem>
+
+                <listitem>
+                    <para>
+                        <code>:controller</code>: MixedCase y camelCasedWords
+                        están separados por guiones; los subrayados se
+                        convierten en separadores de directorio , y el string
+                        emitido a minúsculas.
+                        Ejemplos: "FooBar" pasa a ser "foo-bar";
+                                  "FooBar_Admin" pasa a ser "foo-bar/admin".
+                    </para>
+
+                    <para>
+                        Internamente, el inflector utiliza los filtros
+                        <classname>Zend_Filter_Word_CamelCaseToDash</classname>,
+                        <classname>Zend_Filter_Word_UnderscoreToSeparator</classname>,
+                        y <classname>Zend_Filter_StringToLower</classname>.
+                    </para>
+                </listitem>
+
+                <listitem>
+                    <para>
+                        <code>:action</code>: MixedCase y camelCasedWords
+                        están separados por guiones; los caracteres
+                        no alfanuméricos son traducidos a guiones,
+                        y el string emitido a minúsculas.
+                        Ejemplos: "fooBar" pasa a ser "foo-bar";
+                        "foo-barBaz" pasa a ser "foo-bar-baz".
+                    </para>
+
+                    <para>
+                        Internamente, el inflector utiliza los filtros
+                        <classname>Zend_Filter_Word_CamelCaseToDash</classname>,
+                        <classname>Zend_Filter_PregReplace</classname>, y
+                        <classname>Zend_Filter_StringToLower</classname>.
+                    </para>
+                </listitem>
+            </itemizedlist>
+        </note>
+
+        <para>
+            Los últimos temas en la API de <code>ViewRenderer</code> son los
+            métodos para determinar realmente los paths de los scripts de vista
+            y el rendering de las vistas.
+            Estos incluyen:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>renderScript($script, $name)</code> permite renderizar
+                    un script con una ruta que especifique, opcionalmente a
+                    un segmento nombrado del path. Cuando se utiliza este
+                    método, <code>ViewRenderer</code> no autodetermina el
+                    nombre del script, en cambio pasa directamente a
+                    <code>$script</code> el argumento directamente al método
+                    del objeto vista <code>render()</code>.
+                </para>
+
+                <note><para>
+                    Una vez que la vista ha sido renderizada al objeto respuesta,
+                    se establece <code>noRender</code> para evitar
+                    accidentalmente renderizar el mismo script de vista varias
+                    veces.
+                </para></note>
+
+                <note>
+                    <para>
+                        Por defecto,
+                        <classname>Zend_Controller_Action::renderScript()</classname>
+                        le delega a <code>ViewRenderer</code> el método
+                        <code>renderScript()</code>.
+                    </para>
+                </note>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>getViewScript($action, $vars)</code> crea el path a
+                    un script de vista basado en la acción pasada y/o cualquier
+                    variables pasadas en <code>$vars</code>.
+                    Las claves para este array pueden incluir cualquiera de las
+                    claves de especificación de paths ('moduleDir',
+                    'module', 'controller', 'action', y 'suffix').
+                    Se utilizarán cualquiera de la variables pasadas;
+                    de lo contrario, se utilizarán valores basados en la
+                    petición actual.
+                </para>
+
+                <para>
+                    <code>getViewScript()</code> utilizará tanto a
+                    <code>viewScriptPathSpec</code> o
+                    <code>viewScriptPathNoControllerSpec</code> sobre la base
+                    establecida del flag <code>noController</code>.
+                </para>
+
+                <para>
+                    Los delimitadores de palabras encontrados en un módulo,
+                    controlador o nombres de acción serán reemplazados por
+                    guiones ('-'). Así pues, si tiene el nombre de controlador
+                    'foo.bar' y la acción 'baz:bat', utilizando la
+                    especificación por defecto del path se traducirá en un
+                    path al script de vista 'foo-bar/baz-bat.phtml'.
+                </para>
+
+                <note>
+                    <para>
+                        Por defecto,
+                        <classname>Zend_Controller_Action::getViewScript()</classname>
+                        delega el método <code>getViewScript()</code> de
+                        <code>ViewRenderer</code>.
+                    </para>
+                </note>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>render($action, $name, $noController)</code>
+                    comprueba primero para ver si bien <code>$name</code> o
+                    <code>$noController</code> se han pasado, y si es así,
+                    establece los flags apropiados (responseSegment y
+                    noController, respectivamente) en ViewRenderer.
+                    A continuación, pasa el argumento <code>$action</code>,
+                    si hay alguno, a <code>getViewScript()</code>.
+                    Por último, pasa el path calculado del script de vista a
+                    <code>renderScript()</code>.
+                </para>
+
+                <note>
+                    <para>
+                        Hay que ser conscientes de los efectos secundarios al
+                        usar render(): los valores que usted pasa para el nombre
+                        del segmento respuesta y para el flag noController
+                        persistirán en el objeto. Además, noRender será
+                        establecido después de completar la renderización.
+                    </para>
+                </note>
+
+                <note>
+                    <para>
+                        Por defecto,
+                        <classname>Zend_Controller_Action::render()</classname>
+                        delega a <code>ViewRenderer</code> el método
+                        <code>render()</code>.
+                    </para>
+                </note>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>renderBySpec($action, $vars, $name)</code>
+                    permite pasar variables de especificación del path a fin de
+                    determinar el path para la creación del script de vista.
+                    Este pasa <code>$action</code> y <code>$vars</code> a
+                    <code>getScriptPath()</code>, y luego pasa el path del
+                    script resultante y <code>$name</code> a
+                    <code>renderScript()</code>.
+                </para>
+            </listitem>
+        </itemizedlist>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelper.viewrenderer.basicusage">
+        <title>Ejemplos Uso Básico</title>
+
+        <example id="zend.controller.actionhelper.viewrenderer.basicusage.example-1">
+            <title>Uso Básico</title>
+
+            <para>
+                En lo más básico, usted simplemente inicializa y registra el
+                ayudante <code>ViewRenderer</code> con el ayudante broker
+                en su bootstrap, y luego establecer las variables en sus
+                métodos de acción.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// En su bootstrap:
+Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
+
+...
+
+// 'foo' módulo, 'bar' controlador:
+class Foo_BarController extends Zend_Controller_Action
+{
+    // Render bar/index.phtml por defecto; no se requieren acciones
+    public function indexAction()
+    {
+    }
+
+    // Render bar/populate.phtml la variable 'foo' establecida a 'bar'.
+    // Dado que el objeto fue definido en preDispatch(), está disponible.
+    public function populateAction()
+    {
+        $this->view->foo = 'bar';
+    }
+
+    // No hace rendering, ya que salta a otra acción; la nueva acción
+    // realizará cualquier rendering
+    public function bazAction()
+    {
+        $this->_forward('index');
+    }
+
+    // No hace rendering, ya que redirecciona a otra ubicación
+    public function batAction()
+    {
+        $this->_redirect('/index');
+    }
+}
+]]></programlisting>
+        </example>
+
+        <note>
+            <title>Convenciones de Nombres: Delimitadores de Palabras en Controladores y Nombres de Acción</title>
+            <para>
+                Si su controlador o nombre de acción está compuesto por varias
+                palabras, el despachador exige que estos sean separados de la URL
+                por un path específico y caracteres delimitadores de palabras.
+                El <code>ViewRenderer</code> reemplaza cualquier delimitador
+                de paths encontrado en el nombre del controlador con el
+                delimitador actual ('/'), y cualquier delimitador de palabra
+                encontrado con un guión ('-') cuando crea paths.
+                Así, una llamada a la acción
+                <code>/foo.bar/baz.bat</code> despachará a
+                <code>FooBarController::bazBatAction()</code> en
+                FooBarController.php, el cual renderizaría a
+                <code>foo-bar/baz-bat.phtml</code>; una llamada a la acción
+                <code>/bar_baz/baz-bat</code> despachará a
+                <code>Bar_BazController::bazBatAction()</code> en
+                <code>Bar/BazController.php</code> (note la separación del path)
+                y renderiza <code>bar/baz/baz-bat.phtml</code>.
+            </para>
+
+            <para>
+                Tener en cuenta que el en el segundo ejemplo, el módulo es
+                todavía el módulo por defecto, pero que, debido a la
+                existencia de un separador de paths, el controlador recibe el
+                nombre <code>Bar_BazController</code>, en
+                code>Bar/BazController.php</code>.
+                El ViewRenderer imita la jerarquía del directorio del
+                controlador.
+            </para>
+        </note>
+
+        <example id="zend.controller.actionhelper.viewrenderer.basicusage.example-2">
+            <title>Deshabilitando Autorender</title>
+
+            <para>
+                Para algunas acciones o controladores, usted puede querer apagar
+                el autorendering -- por ejemplo, si quiere emitir un tipo
+                diferente de salida (XML, JSON, etc), o si simplemente no desea
+                emitir nada.
+                Tiene dos opciones: apagar todos los casos de autorendering
+                (<code>setNeverRender()</code>), o simplemente desactivarlo
+                para la acción actual (<code>setNoRender()</code>).
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// Baz clase del controlador, bar módulo:
+class Bar_BazController extends Zend_Controller_Action
+{
+    public function fooAction()
+    {
+        // No auto renderize esta acción
+        $this->_helper->viewRenderer->setNoRender();
+    }
+}
+
+// Bat clase del controlador, bar módulo:
+class Bar_BatController extends Zend_Controller_Action
+{
+    public function preDispatch()
+    {
+        // Nunca auto renderizar las acciones de este controlador
+        $this->_helper->viewRenderer->setNoRender();
+    }
+}
+]]></programlisting>
+        </example>
+
+        <note>
+            <para>
+                En muchos casos, no tiene sentido desactivar el autorendering
+                globalmente (ala <code>setNeverRender()</code>), y la única
+                cosa que puede ganar de <code>ViewRenderer</code> es el
+                autosetup del objeto de vista.
+            </para>
+        </note>
+
+        <example id="zend.controller.actionhelper.viewrenderer.basicusage.example-3">
+            <title>Eligiendo Un Script de Vista Diferente</title>
+
+            <para>
+                Algunas situaciones requieren renderizar un script diferente
+                al llamado después de la acción. Por ejemplo, si tiene un
+                controlador que tiene tanto las acciones de agregar y de editar,
+                ambos pueden mostrar la misma vista 'form', aunque con diferentes
+                valores establecidos. Puede cambiar fácilmente el nombre
+                del script usado tanto con
+                <code>setScriptAction()</code>, <code>setRender()</code>, o
+                llamando al ayudante como un método, que invocará a
+                <code>setRender()</code>.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// Bar clase controlador, foo módulo:
+class Foo_BarController extends Zend_Controller_Action
+{
+    public function addAction()
+    {
+        // Render 'bar/form.phtml' en lugar de 'bar/add.phtml'
+        $this->_helper->viewRenderer('form');
+    }
+
+    public function editAction()
+    {
+        // Render 'bar/form.phtml' en lugar de 'bar/edit.phtml'
+        $this->_helper->viewRenderer->setScriptAction('form');
+    }
+
+    public function processAction()
+    {
+        // hacer alguna validación...
+        if (!$valid) {
+            // Render 'bar/form.phtml' en lugar de 'bar/process.phtml'
+            $this->_helper->viewRenderer->setRender('form');
+            return;
+        }
+
+        // de otra manera, continuar procesando...
+    }
+
+}
+]]></programlisting>
+        </example>
+
+        <example id="zend.controller.actionhelper.viewrenderer.basicusage.example-4">
+            <title>Modificando la Vista Registrada</title>
+
+            <para>
+                ¿Y si se necesita modificar el objeto vista --
+                por ejemplo, cambiar el ayudante de paths, o la codificación?.
+                Puede hacerlo ya sea por modificar el objeto vista establecido
+                en su controlador, o arrebatándole el objeto vista a
+                <code>ViewRenderer</code>; ambas son referencias al mismo objeto.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// Bar clase controlador, foo módulo:
+class Foo_BarController extends Zend_Controller_Action
+{
+    public function preDispatch()
+    {
+        // cambiar la codificavión de la vista
+        $this->view->setEncoding('UTF-8');
+    }
+
+    public function bazAction()
+    {
+        // Obtener el objeto vista y establecer
+        // el callback de escape a 'htmlspecialchars'
+        $view = $this->_helper->viewRenderer->view;
+        $view->setEscape('htmlspecialchars');
+    }
+}
+]]></programlisting>
+        </example>
+    </sect4>
+
+    <sect4 id="zend.controller.actionhelper.viewrenderer.advancedusage">
+        <title>Ejemplos de Uso Avanzado</title>
+
+        <example id="zend.controller.actionhelper.viewrenderer.advancedusage.example-1">
+            <title>Cambiando las Especificaciones del Path</title>
+
+            <para>
+                En algunas circunstancias, puede decidir que las
+                especificaciones del path por defecto no se adaptan a su sitio.
+                Por ejemplo, usted puede querer tener un árbol único de
+                plantillas al que puede dar acceso a sus diseñadores
+                (esto es muy típico cuando se utiliza
+                <ulink url="http://smarty.php.net/">Smarty</ulink>, por
+                ejemplo). En ese caso, puede querer embeber los datos de la
+                especificación del path base de la vista, y crear una
+                especificación alternativa para el script de vista del path
+                ellos mismos.
+            </para>
+
+            <para>
+                Para los fines de este ejemplo, supongamos que el path base
+                de las vistas debería ser '/opt/vendor/templates', y que desea
+                para que los scripts de vista sean referenciados por
+                ':moduleDir/:controller/:action.:suffix'; si el flag
+                noController ha sido establecido, quiere renderizar
+                fuera del nivel superior en lugar de en un subdirectorio
+                (':action.:suffix'). Por último, que quiere utilizar 'tpl'
+                como el sufijo del nombre de archivo del script de vista.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+/**
+ * En su bootstrap:
+ */
+
+// Implementación de una vista diferente
+$view = new ZF_Smarty();
+
+$viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer($view);
+$viewRenderer->setViewBasePathSpec('/opt/vendor/templates')
+             ->setViewScriptPathSpec(':module/:controller/:action.:suffix')
+             ->setViewScriptPathNoControllerSpec(':action.:suffix')
+             ->setViewSuffix('tpl');
+Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
+]]></programlisting>
+        </example>
+
+        <example id="zend.controller.actionhelper.viewrenderer.advancedusage.example-2">
+            <title>Rendering Múltiples Scripts de Vista desde una Sola Acción</title>
+
+            <para>
+                A veces, puede que necesite renderizar múltiples scripts de
+                vista desde una sola acción. Esto es muy sencillo --
+                simplemente hacer múltiples llamadas a <code>render()</code>:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+class SearchController extends Zend_Controller_Action
+{
+    public function resultsAction()
+    {
+        // Suponga que $this->model es el modelo actual
+        $this->view->results =
+            $this->model->find($this->_getParam('query', '');
+
+        // render() por defecto lo delega al ViewRenderer
+        // Render primero al from de búsqueda y luego los resultados
+        $this->render('form');
+        $this->render('results');
+    }
+
+    public function formAction()
+    {
+        // No hacer nada; ViewRenderer hace autorender del script de vista
+    }
+}
+]]></programlisting>
+        </example>
+    </sect4>
+</sect3>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-Basics.xml

@@ -0,0 +1,226 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.controller.basics">
+    <title>Conceptos Básicos de Zend_Controller</title>
+
+    <para>
+        El sistema <classname>Zend_Controller</classname> está diseñado para
+        ser liviano, modular y extensible. Se trata de un diseño minimalista
+        para permitir flexibilidad y cierta libertad para los usuarios
+        proporcionando al mismo tiempo suficiente estructura para que sistemas
+        construidos alrededor de <classname>Zend_Controller</classname>
+        compartan algunas convenciones y layouts de código similares.
+    </para>
+
+    <para>
+        El siguiente diagrama muestra el flujo de trabajo, y la narrativa
+        que le sigue describe en detalle las interacciones:
+    </para>
+
+    <para>
+        <inlinegraphic width="483" scale="100" align="center" valign="middle"
+            fileref="figures/zend.controller.basics.png" format="PNG" />
+    </para>
+
+    <para>
+        El workflow de <classname>Zend_Controller</classname> está implementado
+        por varios componentes. Si bien no es necesario entender los cimientos
+        de todos estos componentes para utilizar el sistema, tener un
+        conocimiento práctico del proceso es de mucha utilidad.
+    </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Front</classname> orquesta todo
+                    el workflow del sistema <classname>Zend_Controller</classname>.
+                    Es una interpretación del patrón FrontController.
+                    <classname>Zend_Controller_Front</classname> procesa todas
+                    las solicitudes recibidas por el servidor y es responsable
+                    en última instancia para delegar requerimientos a los
+                    ActionControllers
+                    (<classname>Zend_Controller_Action</classname>).
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Request_Abstract</classname> (a
+                    menudo denominado <code>Request Object</code>) representa
+                    el medio ambiente de la solicitud y ofrece métodos para
+                    establecer y recuperar el controlador, los nombres de
+                    acción y cualquier parámetro de solicitd. Además mantiene
+                    la pista de si la acción que contiene ha sido enviada o no
+                    por <classname>Zend_Controller_Dispatcher</classname>.
+                    Se pueden uar extensiones del objeto abstracto para
+                    encapsular toda el medio ambiente de la solicitud,
+                    permitiendo a los routers traer información del medio
+                    ambiente de la solicitud a fin de establecer el controlador
+                    y los nombres de acción.
+                </para>
+
+                <para>
+                    Por defecto, se usa
+                    <classname>Zend_Controller_Request_Http</classname>, que
+                    proporciona acceso a todo el medio ambiente de la petición
+                    HTTP.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Router_Interface</classname>
+                    se usa para definir routers. El ruteo es el proceso de
+                    examinar el medio ambiente de la solicitud para determinar
+                    qué controlador, y qué acción del contralor debe recibir
+                    la solicitud. Este controlador, la acción, y los parámetros
+                    opcionales son luego establecidos en el objeto solicitud
+                    para ser procesados por
+                    <classname>Zend_Controller_Dispatcher_Standard</classname>.
+                    El ruteo (routing) ocurre sólo una vez: cuando la solicitud
+                    se recibie inicialmente y antes de despachar el primer
+                    controlador.
+                </para>
+
+                <para>
+                    El router por defecto,
+                    <classname>Zend_Controller_Router_Rewrite</classname>,
+                    toma el punto final de una URI como se especidicó en
+                    <classname>Zend_Controller_Request_Http</classname>
+                    y la descompone en un controlador, acción y parámetros
+                    basados en la información del path en la url.
+                    Como ejemplo, la URL
+                    <code>http://localhost/foo/bar/key/value</code> se
+                    decodificará para usar el controlador <code>foo</code>,
+                    la acción <code>bar</code> y especificar un parámetro
+                    <code>key</code> con el valor de <code>value</code>.
+                </para>
+
+                <para>
+                    <classname>Zend_Controller_Router_Rewrite</classname>
+                    también puede ser utilizado para igualar paths arbitrarios;
+                    para más información, ver <link
+                        linkend="zend.controller.router">documentación
+                        del router</link>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Dispatcher_Interface</classname>
+                    se usa para definir despachadores. Despachar es el proceso
+                    de sacar el controlador y la acción del objeto solicitud y
+                    mapearlo a un controlador archivo/clase y al método acción
+                    en la clase del controlador. Si el controlador o acción no
+                    existen, hará un manejo para determinar los controladores
+                    por defecto y las acciones a despachar.
+                </para>
+
+                <para>
+                    El proceso actual de despacho consta de instanciar la
+                    clase del controlador y llamar al método acción en esa
+                    clase. A diferencia del routing, que ocurre sólo una vez,
+                    el despacho ocurre en un bucle. Si el status del objeto
+                    solicitud despachado es reseteado en cualquier punto,
+                    el bucle se repetirá, llamando a cualquier acción que esté
+                    actualmente establecida en el objeto solicitud.
+                    La primera vez el bucle termina con el objeto solicitud,
+                    el status de lo despachado se establece a (booleano true),
+                    que terminará el procesamiento.
+                </para>
+
+                <para>
+                    El despachador por defecto es
+                    <classname>Zend_Controller_Dispatcher_Standard</classname>.
+                    Se definen como controladores MixedCasedClasses cuando
+                    terminan en la palabra Controller, y los métodos de acción
+                    como camelCasedMethods cuando terminan en la palabra Action:
+                    <code>FooController::barAction()</code>. En este caso,
+                    el controlador será referido como <code>foo</code> y a la
+                    acción como <code>bar</code>.
+                </para>
+
+                <note>
+                    <title>Convenciones para Case Naming</title>
+
+                    <para>
+                        Dado que los humanos somos notablemente inconsistentes
+                        en mantener cierta sensibilidad respecto a las
+                        minúsculas y mayúusculas al escribir enlaces,
+                        Zend Framework realmente normaliza ls información del
+                        path a minúsculas. Esto, por supuesto, afectará cómo
+                        nombre usted a su controlador y acciones... o referirse
+                        a ellos en los enlaces.
+                    </para>
+
+                    <para>
+                        Si desea que su clase controlador o el nombre del
+                        método de la acción tenga múltiples MixedCasedWords o
+                        camelCasedWords, para separar las palabras en la RUL
+                        necesitará hacerlo con un '-' o '.' (aunque puede
+                        configurar el carácter utilizado).
+                    </para>
+
+                    <para>
+                        Como ejemplo, si se va a la acción en
+                        <code>FooBarController::bazBatAction()</code>,
+                        se referirá a ella en la URL como
+                        <code>/foo-bar/baz-bat</code>
+                        o <code>/foo.bar/baz.bat</code>.
+                    </para>
+                </note>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Action</classname>
+                    es el componente base del controlador de acción.
+                    Cada controlador es una sola clase que extiende la
+                    <classname>Zend_Controller_Action class</classname>
+                    y debe contener uno o más métodos de acción.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Response_Abstract</classname>
+                    define una clase base de respuesta utilizada para recoger y
+                    retornar respuestas de los controladores de acción.
+                    Recoge tanto a las cabeceras como al contenido del cuerpo.
+                </para>
+
+                <para>
+                    La clase respuesta por defecto es
+                    <classname>Zend_Controller_Response_Http</classname>,
+                    la cual es adecuada para usarla en un entorno HTTP.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+    <para>
+        El workflow de <classname>Zend_Controller</classname> es relativamente
+        sencillo. Una solicitud es recibida por
+        <classname>Zend_Controller_Front</classname>, la que a su vez llama a
+        <classname>Zend_Controller_Router_Rewrite</classname>
+        para determinar qué controlador (y la acción en ese contralor)
+        despachar.
+        <classname>Zend_Controller_Router_Rewrite</classname>
+        descompone la URI a fin de establecer el controlador y el nombre de
+        acción en la solicitud.
+        <classname>Zend_Controller_Front</classname>
+        entonces entra al loop de despacho. Llama a
+        <classname>Zend_Controller_Dispatcher_Standard</classname>,
+        le pasa la solicitud para despachar al contralor y a la acción
+        especificada en la solicitud (o el usado por defecto).
+        Después de que el contralor ha terminado, el control vuelve a
+        <classname>Zend_Controller_Front</classname>.
+        Si el contralor ha indicado que debe despacharse otro controlador
+        mediante el reinicio de la condición (status) de la solicitud,
+        el bucle continúa y se ejecuta otro despacho.
+        En caso contrario el proceso termina.
+    </para>
+</sect1>
+
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-Dispatcher.xml

@@ -0,0 +1,306 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.controller.dispatcher">
+    <title>El Despachador</title>
+
+    <sect2 id="zend.controller.dispatcher.overview">
+        <title>Introducción</title>
+
+        <para>
+            Despachar es el proceso de tomar el objeto solicitud,
+            <classname>Zend_Controller_Request_Abstract</classname>,
+            extraer el nombre del módulo, el nombre del controlador, el nombre
+            de la acción, y los parámetros opcionales contenido en él, y luego
+            instanciar un controlador y llamar una acción de ese controlador.
+            Si no se encuentra algún módulo, controlador o acción, se usarán
+            los valores por defecto para ellos.
+            <classname>Zend_Controller_Dispatcher_Standard</classname>
+            especifica <code>index</code> para cada uno de los controladores y
+            acciones por defecto y <code>default</code> para el valor por
+            defecto del módulo, pero permite al desarrollador cambiar los
+            valores por defecto para cada uno usando los métodos
+            <code>setDefaultController()</code>,
+            <code>setDefaultAction()</code>, y <code>setDefaultModule()</code>
+            respectivamente.
+        </para>
+
+        <note>
+            <title>Módulo por Defecto</title>
+
+            <para>
+                Cuando se crean aplicaciones modulares, puede encontrarse
+                queriendo también el namespace por defecto del módulo (la
+                configuración por defecto es que el módulo por defecto es
+                <emphasis>no</emphasis> namespaced).
+                Como de 1.5.0, ahora puede hacerlo especificando el
+                <code>prefixDefaultModule</code> como verdadero tanto en el
+                front controller como es su despachador:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// En su front controller:
+$front->setParam('prefixDefaultModule', true);
+
+// En su despachador:
+$dispatcher->setParam('prefixDefaultModule', true);
+]]></programlisting>
+
+            <para>
+                Esto le permite re-determinar un módulo existente para ser el
+                módulo por defecto para una solicitud.
+            </para>
+        </note>
+
+        <para>
+            El proceso de despachar tiene lugar en un bucle en el front controller.
+            Antes de llevarse a cabo el despacho, el front controller rutea la
+            solicitud para encontrar valores especificados por el usuario para
+            el módulo, controlador, acción, y los parámetros opcionales.
+            A continuación entra en un loop de despacho, despachando la
+            solicitud.
+        </para>
+
+        <para>
+            Al comienzo de cada iteración, establece un flag en el objeto
+            solicitud indicando que la acción se ha despachado.
+            Si una acción o un plugin pre/postDispatch resetea ese flag,
+            el loop de despacho continuará e intentará despachar la nueva
+            solicitud. Cambiando el controlador y/o la acción en la solicitud y
+            reseteando el flag despachado, el desarrollador puede definir
+            una cadena de peticiones a realizar.
+        </para>
+
+        <para>
+            El método del controlador de acción que controla ese despacho es
+            <code>_forward()</code>; llamar a este método para cualquiera de los
+            pre/postDispatch() o métodos de acción, proporcionando un
+            controlador de acciónes, módulo y, opcionalmente cualquier parámetro
+            adicional que desee enviar a la nueva acción:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+public function fooAction()
+{
+    // adelantar a otra acción en el controlador y módulo actuales:
+    $this->_forward('bar', null, null, array('baz' => 'bogus'));
+}
+
+public function barAction()
+{
+    // adelantar a una acción en otro controlador:
+    // FooController::bazAction(),
+    // en el módulo actual:
+    $this->_forward('baz', 'foo', null, array('baz' => 'bogus'));
+}
+
+public function bazAction()
+{
+    // adelantar a una acción en otro controlador en otro módulo,
+    // Foo_BarController::bazAction():
+    $this->_forward('baz', 'bar', 'foo', array('baz' => 'bogus'));
+}
+]]></programlisting>
+    </sect2>
+
+    <sect2 id="zend.controller.dispatcher.subclassing">
+        <title>Subclaseando el Despachador</title>
+
+        <para>
+            <classname>Zend_Controller_Front</classname> llamará en primer lugar
+            al router para determinar la primera acción en la solicitud.
+            A continuación se entra en un loop de despacho, el cual llama al
+            despachador para despachar la acción.
+        </para>
+
+        <para>
+            El despachador necesita de una variedad de datos a fin de hacer su
+            trabajo - necesita saber cómo formatear los nombres del controlador
+            y de la acción, dónde mirar para los archivos de clase del
+            controlador, cuándo el nombre de un controlador provisto es válido
+            o no, y una API para determinar si una determinada solicitud es
+            incluso despachable basado en la otra información disponible.
+        </para>
+
+        <para>
+            <classname>Zend_Controller_Dispatcher_Interface</classname>
+            define los siguientes métodos como necesarios para cualquier
+            implementación de un despachador:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+interface Zend_Controller_Dispatcher_Interface
+{
+    /**
+     * Formatea un string dentro del nombre de clase del controlador.
+     *
+     * @param string $unformatted
+     * @return string
+     */
+    public function formatControllerName($unformatted);
+
+    /**
+     * Formatea un string dentro de un nombre de método de acción.
+     *
+     * @param string $unformatted
+     * @return string
+     */
+    public function formatActionName($unformatted);
+
+    /**
+     * Determina si la solicitud es despachable
+     *
+     * @param  Zend_Controller_Request_Abstract $request
+     * @return boolean
+     */
+    public function isDispatchable(
+        Zend_Controller_Request_Abstract $request
+    );
+
+    /**
+     * Establece un parámetro de usuario (via front controller, o para uso local)
+     *
+     * @param string $name
+     * @param mixed $value
+     * @return Zend_Controller_Dispatcher_Interface
+     */
+    public function setParam($name, $value);
+
+    /**
+     * Establece un array de parámetros de usuario
+     *
+     * @param array $params
+     * @return Zend_Controller_Dispatcher_Interface
+     */
+    public function setParams(array $params);
+
+    /**
+     * Recupera un único parámetro de usuario
+     *
+     * @param string $name
+     * @return mixed
+     */
+    public function getParam($name);
+
+    /**
+     * Recupera todos los parámetros de usuario
+     *
+     * @return array
+     */
+    public function getParams();
+
+    /**
+     * Limpia el stack de parámetros de usuario, o un único parámetro de usuario
+     *
+     * @param null|string|array single key or array of keys for
+     *        params to clear
+     * @return Zend_Controller_Dispatcher_Interface
+     */
+    public function clearParams($name = null);
+
+    /**
+     * Establece el objeto respuesta a usar, si hubiera alguno
+     *
+     * @param Zend_Controller_Response_Abstract|null $response
+     * @return void
+     */
+    public function setResponse(
+        Zend_Controller_Response_Abstract $response = null
+    );
+
+    /**
+     * Recupera el objeto respuesta, si hubiera alguno
+     *
+     * @return Zend_Controller_Response_Abstract|null
+     */
+    public function getResponse();
+
+    /**
+     * Agrega un directorio de controladoes al stack de directorios de controladores
+     *
+     * @param string $path
+     * @param string $args
+     * @return Zend_Controller_Dispatcher_Interface
+     */
+    public function addControllerDirectory($path, $args = null);
+
+    /**
+     * Establece el directorio (o directorios) donde se almacenan los archivos
+     * de controladoes
+     *
+     * @param string|array $dir
+     * @return Zend_Controller_Dispatcher_Interface
+     */
+    public function setControllerDirectory($path);
+
+    /**
+     * Regresa el directorio(s) actualmente establecido para el lookup de los
+     * archivos de controladores
+     *
+     * @return array
+     */
+    public function getControllerDirectory();
+
+    /**
+     * Despacha una solicitud a una acción de (módulo/)controlador.
+     *
+     * @param  Zend_Controller_Request_Abstract $request
+     * @param  Zend_Controller_Response_Abstract $response
+     * @return Zend_Controller_Request_Abstract|boolean
+     */
+    public function dispatch(
+        Zend_Controller_Request_Abstract $request,
+        Zend_Controller_Response_Abstract $response
+    );
+
+    /**
+     * Si un módulo dado es válido o no
+     *
+     * @param string $module
+     * @return boolean
+     */
+    public function isValidModule($module);
+
+    /**
+     * Recuperar el nombre por defecto del módulo
+     *
+     * @return string
+     */
+    public function getDefaultModule();
+
+    /**
+     * Recuperar el nombre por defecto del controlador
+     *
+     * @return string
+     */
+    public function getDefaultControllerName();
+
+    /**
+     * Recuperar la acción por defecto
+     *
+     * @return string
+     */
+    public function getDefaultAction();
+}
+]]></programlisting>
+
+        <para>
+            En muchos casos, sin embargo, simplemente debe extender la clase
+            abstracta <classname>Zend_Controller_Dispatcher_Abstract</classname>,
+            en el que cada uno de estas ya han sido definidas, o
+            <classname>Zend_Controller_Dispatcher_Standard</classname>
+            para modificar la funcionalidad del despachador estándar.
+        </para>
+
+        <para>
+            Las posibles razones para subclasear al despachador incluye un
+            deseo de utilizar un esquema diferente para nombrar las clases o
+            métodos en sus controladores de acción, o el deseo de utilizar otro
+            paradigma de despacho como ser despachar los archivos de acción
+            bajo directorios de controladores (en lugar de despacharlos a los
+            métodos de clase).
+        </para>
+    </sect2>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-Exceptions.xml

@@ -0,0 +1,387 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.controller.exceptions">
+    <title>Excepciones MVC</title>
+
+    <sect2 id="zend.controller.exceptions.introduction">
+        <title>Introducción</title>
+
+        <para>
+            Los componentes MVC en Zend Framework utilizan un Front Controller,
+            lo que significa que todas las solicitudes de un determinado
+            sitio pasarán por un solo punto de entrada. Como resultado, todas
+            las excepciones burbujearán eventualmente hacia arriba hasta el
+            Front Controller, permitiendo al desarrollador manejarlos en un
+            solo lugar.
+        </para>
+
+        <para>
+            Sin embargo, los mensajes de excepción y la información de backtrace
+            contienen a menudo información sensible del sistema, como
+            declaraciones SQL, ubicaciones de archivos y otras cosas más.
+            Para ayudar a proteger su sitio, por defecto
+            <classname>Zend_Controller_Front</classname> captura todas las
+            excepciones y las registra con el objeto respuesta; a su vez, y
+            por defecto, el objeto respuesta no muestra mensajes de excepción.
+        </para>
+    </sect2>
+
+    <sect2 id="zend.controller.exceptions.handling">
+        <title>Manejando las Excepciones</title>
+
+        <para>
+            Ya hay varios mecanismos construidos en los componentes de MVC,
+            que le permiten manejar excepciones.
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    Por defecto, el <link
+                        linkend="zend.controller.plugins.standard.errorhandler">error
+                    handler plugin</link> está registrado y activo.
+                    Este plugin fue diseñado para manejar:
+                </para>
+
+                <itemizedlist>
+                    <listitem><para>Errores debido a controladores o acciones perdidas</para></listitem>
+
+                    <listitem><para>Errores ocurriendo dentro de controladores de acción</para></listitem>
+                </itemizedlist>
+
+                <para>
+                    Operan como un plugin de <code>postDispatch()</code>,
+                    y comprueban para ver si un despachador, controlador de
+                    acción, o de otra excepción ha ocurrido.
+                    Si así fuera, lo remite a un controlador de manejo de
+                    errores.
+                </para>
+
+                <para>
+                    Este manejador abarcará la mayoría de las situaciones
+                    excepcionales, y maneja airosamente controladores y acciones
+                    perdidos.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para><classname>Zend_Controller_Front::throwExceptions()</classname></para>
+
+                <para>
+                    Pasando a este método un valor booleano verdadero,
+                    puede decirle al front controller que, en lugar
+                    de sumar excepciones en el objeto respuesta o utilizando
+                    el plugin de manejo de errores, prefiere manejarlos usted mismo.
+                    Como ejemplo:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+$front->throwExceptions(true);
+try {
+    $front->dispatch();
+} catch (Exception $e) {
+    // usted mismo maneja las excepciones
+}
+]]></programlisting>
+
+                <para>
+                    Este método es probablemente la forma más fácil de añadir
+                    un manejo de excepciones personalizado que abarque toda la
+                    gama de posibles excepciones a su aplicación de
+                    front controller.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para><classname>Zend_Controller_Response_Abstract::renderExceptions()</classname></para>
+
+                <para>
+                    Al pasar a este método un valor booleano verdadero,
+                    le esta diciendo al objeto respuesta que debe emitir un
+                    mensaje de excepción y backtrace cuando se renderiza a sí
+                    mismo.
+                    En este escenario, se mostrará cualquier excepción planteada
+                    por su aplicación. Esto no es recomendable para entornos de
+                    producción, pero sí en desarrollo.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Front::returnResponse()</classname> y
+                    <classname>Zend_Controller_Response_Abstract::isException()</classname>.
+                </para>
+
+                <para>
+                    Pasando un valor booleano verdadero a
+                    <classname>Zend_Controller_Front::returnResponse()</classname>,
+                    <classname>Zend_Controller_Front::dispatch()</classname>
+                    no renderizará la respuesta, sino que la devolverá.
+                    Una vez que tiene la respuesta, entonces puede probar ver
+                    si todas las excepciones fueron atrapadas usando su método
+                    <code>isException()</code>, y recuperando las excepciones
+                    a través del método <code>getException()</code>.
+                    Como ejemplo:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+$front->returnResponse(true);
+$response = $front->dispatch();
+if ($response->isException()) {
+    $exceptions = $response->getException();
+    // maneje las excepciones ...
+} else {
+    $response->sendHeaders();
+    $response->outputBody();
+}
+]]></programlisting>
+
+                <para>
+                    La principal ventaja que este método ofrece por sobre
+                    <classname>Zend_Controller_Front::throwExceptions()</classname>
+                    es que le permite renderizar condicionalmente la respuesta
+                    después de manejar la excepción. Esta capturará cualquier
+                    excepción en la cadena de controladores, a diferencia del
+                    plugin de manejo de errores.
+                </para>
+            </listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.controller.exceptions.internal">
+        <title>Excepciones MVC que Usted Pueda Encontrar</title>
+
+        <para>
+            Los diversos componentes de MVC -- solicitud, router, despachador,
+            controlador de acción, y los objetos respuesta -- pueden arrojar
+            excepciones en ocasiones.
+            Algunas excepciones puede ser condicionalmente anuladas,
+            y otras se usan para indicar al desarrollador que puede necesitar
+            re-considerar la estructura de su aplicación.
+        </para>
+
+        <para>Como algunos ejemplos:</para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Dispatcher::dispatch()</classname>
+                    hará, por defecto, arrojar una excepción si se hace un
+                    requerimiento a un controlador no válido.
+                    Hay dos maneras recomendadas para lidiar con esto.
+                </para>
+
+                <itemizedlist>
+                    <listitem>
+                        <para>Establecer el parámetro
+                             <code>useDefaultControllerAlways</code>.
+                        </para>
+
+                        <para>
+                            En su front controller, o en su despachador,
+                            añada la siguiente directiva:
+                        </para>
+
+                        <programlisting role="php"><![CDATA[
+$front->setParam('useDefaultControllerAlways', true);
+
+// o
+
+$dispatcher->setParam('useDefaultControllerAlways', true);
+]]></programlisting>
+
+                        <para>
+                            Cuando este flag está establecido, el despachador
+                            utilizará el controlador y la acción por defecto
+                            en lugar de lanzar una excepción.
+                            La desventaja de este método es que cualquier
+                            error ortográfico que un usuario haga cuando
+                            acceda a su sitio lo resolverá y mostrará su
+                            página de inicio, y que puede causar estragos
+                            con la optimización para los motores de búsqueda.
+                        </para>
+                    </listitem>
+
+                    <listitem>
+                        <para>
+                            La excepción arrojada por <code>dispatch()</code> es
+                            una <classname>Zend_Controller_Dispatcher_Exception</classname>
+                            conteniendo el texto 'Invalid controller specified'.
+                            Use uno de los métodos descriptos de <link
+                                linkend="zend.controller.exceptions.handling">la
+                                sección anterior</link> para atrapar la
+                                excepción, y luego redireccionar a una página
+                                genérica de error o a la página de inicio.
+                        </para>
+                    </listitem>
+                </itemizedlist>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Action::__call()</classname>
+                    arrojará una
+                    <classname>Zend_Controller_Action_Exception</classname>
+                    si no puede despachar una acción inexistente a un método.
+                    Es probable que desee utilizar alguna acción por defecto
+                    en el controlador en casos como este.
+                    Formas de lograr esto incluyen:
+                </para>
+
+                <itemizedlist>
+                    <listitem>
+                        <para>
+                            Subclasear <classname>Zend_Controller_Action</classname> y
+                            anular el método <code>__call()</code>.
+                            Como ejemplo:
+                        </para>
+
+                        <programlisting role="php"><![CDATA[
+class My_Controller_Action extends Zend_Controller_Action
+{
+    public function __call($method, $args)
+    {
+        if ('Action' == substr($method, -6)) {
+            $controller = $this->getRequest()->getControllerName();
+            $url = '/' . $controller . '/index';
+            return $this->_redirect($url);
+        }
+
+        throw new Exception('Invalid method');
+    }
+}
+]]></programlisting>
+                        <para>
+                            El ejemplo anterior intercepta cualquier llamada a
+                            un método de acción indefinido y redirecciona a la
+                            acción predeterminada en el controlador.
+                        </para>
+                    </listitem>
+
+                    <listitem>
+                        <para>
+                            Subclasea a <classname>Zend_Controller_Dispatcher</classname>
+                            y anula el método <code>getAction()</code>
+                            para verificar si la acción existe.
+                            Como ejemplo:
+                        </para>
+
+                        <programlisting role="php"><![CDATA[
+class My_Controller_Dispatcher extends Zend_Controller_Dispatcher
+{
+    public function getAction($request)
+    {
+        $action = $request->getActionName();
+        if (empty($action)) {
+            $action = $this->getDefaultAction();
+            $request->setActionName($action);
+            $action = $this->formatActionName($action);
+        } else {
+            $controller = $this->getController();
+            $action     = $this->formatActionName($action);
+            if (!method_exists($controller, $action)) {
+                $action = $this->getDefaultAction();
+                $request->setActionName($action);
+                $action = $this->formatActionName($action);
+            }
+        }
+
+        return $action;
+    }
+}
+]]></programlisting>
+
+                        <para>
+                            El código anterior comprueba para ver que las
+                            acciones solicitadas existan en la clase del
+                            controlador; si no, se restablece la acción a la
+                            acción por defecto.
+                        </para>
+
+                        <para>
+                            Este método es agradable porque puede alterar
+                            transparentemente la acción antes del último
+                            despacho. Sin embargo, también significa que errores
+                            ortográficos en la URL todavía pueden despacharse
+                            correctamente, lo que no es muy bueno para la
+                            optimización en un motor de búsqueda.
+                        </para>
+                    </listitem>
+
+                    <listitem>
+                        <para>
+                            Use
+                            <classname>Zend_Controller_Action::preDispatch()</classname>
+                            o
+                            <classname>Zend_Controller_Plugin_Abstract::preDispatch()</classname>
+                            para identificar acciones inválidas.
+                        </para>
+
+                        <para>
+                            Subclaseando <classname>Zend_Controller_Action</classname>
+                            y modificando <code>preDispatch()</code>,
+                            puede modificar todos sus controladores que
+                            transmitan a otra acción o redireccionar antes de
+                            despachar la acción. El código para hacer esto se
+                            verá parecido al código de sustitución de arriba
+                            <code>__call()</code>.
+                        </para>
+
+                        <para>
+                            Alternativamente, puede verificar esta información
+                            en un plugin global. Esto tiene la ventaja de ser
+                            independiente del controlador de acción; si su
+                            aplicación consiste en una variedad de controladores
+                            de acción, y no todos ellos heredan de la misma clase,
+                            este método puede añadir coherencia a su manejo de
+                            clases diferentes.
+                        </para>
+
+                        <para>
+                            Como ejemplo:
+                        </para>
+
+                        <programlisting role="php"><![CDATA[
+class My_Controller_PreDispatchPlugin extends Zend_Controller_Plugin_Abstract
+{
+    public function preDispatch(Zend_Controller_Request_Abstract $request)
+    {
+        $front      = Zend_Controller_Front::getInstance();
+        $dispatcher = $front->getDispatcher();
+        $class      = $dispatcher->getControllerClass($request);
+        if (!$controller) {
+            $class = $dispatcher->getDefaultControllerClass($request);
+        }
+
+        $r      = new ReflectionClass($class);
+        $action = $dispatcher->getActionMethod($request);
+
+        if (!$r->hasMethod($action)) {
+            $defaultAction  = $dispatcher->getDefaultAction();
+            $controllerName = $request->getControllerName();
+            $response       = $front->getResponse();
+            $response->setRedirect('/' . $controllerName
+                                  . '/' . $defaultAction);
+            $response->sendHeaders();
+            exit;
+        }
+    }
+}
+]]></programlisting>
+
+                        <para>
+                            En este ejemplo, vamos a consultar para ver si la
+                            acción solicitada está disponible en el controlador.
+                            Si no, redireccionamos a la acción predeterminada
+                            en el controlador, y salimos inmediatamente de la
+                            ejecución del script.
+                        </para>
+                    </listitem>
+                </itemizedlist>
+            </listitem>
+        </itemizedlist>
+    </sect2>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-FrontController.xml

@@ -0,0 +1,581 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.controller.front">
+    <title>El Front Controller</title>
+
+    <sect2 id="zend.controller.front.overview">
+        <title>Introducción</title>
+
+        <para>
+            <classname>Zend_Controller_Front</classname> implementa un <ulink
+                url="http://www.martinfowler.com/eaaCatalog/frontController.html">Front
+                Controller pattern</ulink> usado en aplicaciones <ulink
+                url="http://en.wikipedia.org/wiki/Model-view-controller">Model-View-Controller
+                (MVC)</ulink>. 
+                Su propósito es inicializar el medio ambiente de la solicitud, 
+                rutear la solicitud entrante, y luego hacer un dispatch de 
+                cualquier de las acciones descubiertas; le agrega las respuestas 
+                y las regresa cuando se completa el proceso.  
+        </para>
+
+        <para>
+            <classname>Zend_Controller_Front</classname> también implementa el <ulink
+                url="http://en.wikipedia.org/wiki/Singleton_pattern">Singleton
+            pattern</ulink>, significando que solo una única instancia de él 
+            puede estar disponible en cualquier momento dado. 
+            Esto le permite actuar también como un registro en el que los demás 
+            objetos puden extraer del proceso dispatch.
+        </para>
+
+        <para>
+            <classname>Zend_Controller_Front</classname> registra un <link
+                linkend="zend.controller.plugins">plugin broker</link> consígo  
+            mismo, permitiendo que diversos eventos que dispara sean observados 
+            por plugins. En muchos casos, esto da el desarrollador la 
+            oportunidad de adaptar el proceso de dispatch al sitio sin la 
+            necesidad de ampliar el Front Controller para añadir funcionalidad.
+        </para>
+
+        <para>
+            Como mínimo, el front controller necesita una o más paths a 
+            directorios que contengan <link linkend="zend.controller.action">
+            action controllers</link> a fin de hacer su trabajo. 
+            Una variedad de métodos también pueden ser invocados para seguir 
+            adaptando el medio ambiente del front controller y ese a sus 
+            helper classes.
+        </para>
+
+        <note>
+            <title>Comportamiento por Defecto</title>
+            <para>
+                Por defecto, el front controller carga el <link
+                    linkend="zend.controller.plugins.standard.errorhandler">ErrorHandler</link>
+                plugin, así como al <link
+                    linkend="zend.controller.actionhelpers.viewrenderer">ViewRenderer</link>
+                action helper plugin. Estos son para simplificar el manejo de 
+                errores y el view renderering en sus controladores, respectivamente.
+            </para>
+
+            <para>
+                Para deshabilitar el <code>ErrorHandler</code>, ejecutar lo 
+                siguiente en cualquier momento antes de llamar a 
+                <code>dispatch()</code>:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// Deshabilitar el ErrorHandler plugin:
+$front->setParam('noErrorHandler', true);
+]]></programlisting>
+
+            <para>
+                Para deshabilitar el <code>ViewRenderer</code>, haga lo 
+                siguiente antes de llamar a <code>dispatch()</code>:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// Deshabilitar el ViewRenderer helper:
+$front->setParam('noViewRenderer', true);
+]]></programlisting>
+        </note>
+    </sect2>
+
+    <sect2 id="zend.controller.front.methods.primary">
+        <title>Métodos Básicos</title>
+
+        <para>
+            El front controller tiene varios accessors para establecer su 
+            medio ambiente. Sin embargo, hay tres métodos básicos clave para la 
+            funcionalidad del front controller:
+        </para>
+
+        <sect3 id="zend.controller.front.methods.primary.getinstance">
+            <title>getInstance()</title>
+
+            <para>
+                <code>getInstance()</code> se utiliza para recuperar una 
+                instancia del front controller. Como el front controller 
+                implementa un patrón Singleton, este también es el único 
+                medio posible para instanciar un objeto front controller.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+$front = Zend_Controller_Front::getInstance();
+]]></programlisting>
+        </sect3>
+
+        <sect3 id="zend.controller.front.methods.primary.setcontrollerdirectory">
+            <title>setControllerDirectory() y addControllerDirectory</title>
+
+            <para>
+                <code>setControllerDirectory()</code> se usa para decirle a <link
+                    linkend="zend.controller.dispatcher">the dispatcher</link>
+                dónde buscar para los archivos de clase <link
+                    linkend="zend.controller.action">action controller</link>.
+                Acepta bien un único path o un array asociativo de pares 
+                módulo/path.
+            </para>
+
+            <para>
+                Como algunos ejemplos:
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// Establer el directorio de controladores por defecto:
+$front->setControllerDirectory('../application/controllers');
+
+// Establecer varios directorios módulos a la vez:
+$front->setControllerDirectory(array(
+    'default' => '../application/controllers',
+    'blog'    => '../modules/blog/controllers',
+    'news'    => '../modules/news/controllers',
+));
+
+// Agregar un directorio de módulos 'foo':
+$front->addControllerDirectory('../modules/foo/controllers', 'foo');
+]]></programlisting>
+
+            <note>
+                <para>
+                    Si usa <code>addControllerDirectory()</code> sin un nombre 
+                    de módulo, este establecerá el directorio 
+                    <code>default</code> para el módulo -- sobreescribiéndolo 
+                    si ya existe.
+                </para>
+            </note>
+
+            <para>
+                Puede conseguir la configuración actual para el directorio del 
+                controlador utilizando <code>getControllerDirectory()</code>; 
+                este devolverá un array de pares módulo/directorio.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.controller.front.methods.primary.addmoduledirectory">
+            <title>addModuleDirectory() y getModuleDirectory()</title>
+
+            <para>
+                Uno de los aspectos del front controller es que puede <link
+                    linkend="zend.controller.modular">definir una estructura 
+                    modular de directorio</link> para crear componentes 
+                    standalone; estos son llamados "módulos".
+            </para>
+
+            <para>
+                Cada módulo debe estar en su propio directorio y ser un espejo 
+                de la estructura del directorio del módulo por defecto -- es 
+                decir, que debería tener como mínimo un subdirectorio de 
+                "controladores", y típicamente un subdirectorio de "views" 
+                y otros subdirectorios de aplicaciones.
+            </para>
+
+            <para>
+                <code>addModuleDirectory()</code> permite pasar el nombre de 
+                un directorio que contiene uno o más directorios de módulos. 
+                A continuación lo analiza y los añade como directorios de 
+                controladores al front controller. 
+            </para>
+
+            <para>
+                Después, si quiere determinar el path a un determinado módulo 
+                o al módulo actual, puede llamar a <code>getModuleDirectory()</code>, 
+                opcionalmente pasar un nombre de módulo para conseguir el  
+                directorio de ese módulo específico.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.controller.front.methods.primary.dispatch">
+            <title>dispatch()</title>
+
+            <para>
+                <code>dispatch(Zend_Controller_Request_Abstract $request = null,
+                    Zend_Controller_Response_Abstract $response = null)</code>
+                hace el trabajo pesado del front controller. Puede opcionalmente 
+                tomar un <link linkend="zend.controller.request">request
+                    object</link> y/o un <link
+                    linkend="zend.controller.response">response object</link>,
+                permitiendo al desarrollador pasar objetos peronalizados para 
+                cada uno.
+            </para>
+
+            <para>
+                Si no se pasa ningun objeto solicitud o respuesta,
+                <code>dispatch()</code> comprobará por objetos previamente 
+                registrados y utilizar esos o instanciar versiones por defecto 
+                a utilizar en su proceso (en ambos casos, el sabor de HTTP será 
+                utilizado por defecto).
+            </para>
+
+            <para>
+                Similarly, <code>dispatch()</code> checks for registered <link
+                    linkend="zend.controller.router">router</link> and <link
+                    linkend="zend.controller.dispatcher">dispatcher</link>
+                objects, instantiating the default versions of each if none is
+                found.
+            </para>
+
+            <para>
+                The dispatch process has three distinct events:
+            </para>
+
+            <itemizedlist>
+                <listitem><para>Routing</para></listitem>
+                <listitem><para>Dispatching</para></listitem>
+                <listitem><para>Response</para></listitem>
+            </itemizedlist>
+
+            <para>
+                Routing takes place exactly once, using the values in the
+                request object when <code>dispatch()</code> is called.
+                Dispatching takes place in a loop; a request may either indicate
+                multiple actions to dispatch, or the controller or a plugin may
+                reset the request object to force additional actions to
+                dispatch. When all is done, the front controller returns a
+                response.
+            </para>
+        </sect3>
+
+        <sect3 id="zend.controller.front.methods.primary.run">
+            <title>run()</title>
+
+            <para>
+                <classname>Zend_Controller_Front::run($path)</classname> is a static
+                method taking simply a path to a directory containing
+                controllers. It fetches a front controller instance (via
+                <link
+                    linkend="zend.controller.front.methods.primary.getinstance">getInstance()</link>,
+                registers the path provided via <link
+                    linkend="zend.controller.front.methods.primary.setcontrollerdirectory">setControllerDirectory()</link>,
+                and finally <link
+                    linkend="zend.controller.front.methods.primary.dispatch">dispatches</link>.
+            </para>
+
+            <para>
+                Basically, <code>run()</code> is a convenience method that can
+                be used for site setups that do not require customization of the
+                front controller environment.
+            </para>
+
+            <programlisting role="php"><![CDATA[
+// Instantiate front controller, set controller directory, and dispatch in one
+// easy step:
+Zend_Controller_Front::run('../application/controllers');
+]]></programlisting>
+        </sect3>
+    </sect2>
+
+    <sect2 id="zend.controller.front.methods.environment">
+        <title>Environmental Accessor Methods</title>
+
+        <para>
+            In addition to the methods listed above, there are a number of
+            accessor methods that can be used to affect the front controller
+            environment -- and thus the environment of the classes to which the
+            front controller delegates.
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>resetInstance()</code> can be used to clear all
+                    current settings. Its primary purpose is for testing, but it
+                    can also be used for instances where you wish to chain
+                    together multiple front controllers.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>(set|get)DefaultControllerName()</code> let you
+                    specify a different name to use for the default controller
+                    ('index' is used otherwise) and retrieve the current value.
+                    They proxy to <link
+                        linkend="zend.controller.dispatcher">the
+                        dispatcher</link>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>(set|get)DefaultAction()</code> let you specify a
+                    different name to use for the default action ('index' is
+                    used otherwise) and retrieve the current value. They proxy
+                    to <link linkend="zend.controller.dispatcher">the
+                        dispatcher</link>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>(set|get)Request()</code> let you specify <link
+                        linkend="zend.controller.request">the request</link>
+                    class or object to use during the dispatch process and to
+                    retrieve the current object. When setting the request
+                    object, you may pass in a request class name, in which case
+                    the method will load the class file and instantiate it.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>(set|get)Router()</code> let you specify <link
+                        linkend="zend.controller.router">the router</link>
+                    class or object to use during the dispatch process and to
+                    retrieve the current object. When setting the router
+                    object, you may pass in a router class name, in which case
+                    the method will load the class file and instantiate it.
+                </para>
+
+                <para>
+                    When retrieving the router object, it first checks to see if
+                    one is present, and if not, instantiates the default router
+                    (rewrite router).
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>(set|get)BaseUrl()</code> let you specify <link
+                        linkend="zend.controller.request.http.baseurl">the base
+                        URL</link> to strip when routing requests and to
+                    retrieve the current value. The value is provided to the
+                    request object just prior to routing.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>(set|get)Dispatcher()</code> let you specify <link
+                        linkend="zend.controller.dispatcher">the
+                        dispatcher</link> class or object to use during the
+                    dispatch process and retrieve the current object. When
+                    setting the dispatcher object, you may pass in a dispatcher
+                    class name, in which case the method will load the class
+                    file and instantiate it.
+                </para>
+
+                <para>
+                    When retrieving the dispatcher object, it first checks to see if
+                    one is present, and if not, instantiates the default
+                    dispatcher.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>(set|get)Response()</code> let you specify <link
+                        linkend="zend.controller.response">the response</link>
+                    class or object to use during the dispatch process and to
+                    retrieve the current object. When setting the response
+                    object, you may pass in a response class name, in which case
+                    the method will load the class file and instantiate it.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>registerPlugin(Zend_Controller_Plugin_Abstract $plugin, $stackIndex = null)</code>
+                    allows you to register <link
+                        linkend="zend.controller.plugins">plugin objects</link>.
+                    By setting the optional <code>$stackIndex</code>, you can
+                    control the order in which plugins will execute.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>unregisterPlugin($plugin)</code> let you
+                    unregister <link
+                        linkend="zend.controller.plugins">plugin objects</link>.
+                    <code>$plugin</code> may be either a plugin object or a
+                    string denoting the class of plugin to unregister.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>throwExceptions($flag)</code> is used to turn on/off
+                    the ability to throw exceptions during the dispatch process.
+                    By default, exceptions are caught and placed in the <link
+                        linkend="zend.controller.response">response
+                        object</link>; turning on <code>throwExceptions()</code>
+                    will override this behaviour.
+                </para>
+
+                <para>
+                    For more information, read <xref
+                        linkend="zend.controller.exceptions" />.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>returnResponse($flag)</code> is used to tell the front
+                    controller whether to return the response
+                    (<code>true</code>) from <code>dispatch()</code>, or if the
+                    response should be automatically emitted
+                    (<code>false</code>). By default, the response is
+                    automatically emitted (by calling
+                    <classname>Zend_Controller_Response_Abstract::sendResponse()</classname>);
+                    turning on <code>returnResponse()</code> will override this
+                    behaviour.
+                </para>
+
+                <para>
+                    Reasons to return the response include a desire to check for
+                    exceptions prior to emitting the response, needing to log
+                    various aspects of the response (such as headers), etc.
+                </para>
+            </listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.controller.front.methods.params">
+        <title>Front Controller Parameters</title>
+
+        <para>
+            In the introduction, we indicated that the front controller also
+            acts as a registry for the various controller components. It does so
+            through a family of "param" methods. These methods allow you to
+            register arbitrary data -- objects and variables -- with the front
+            controller to be retrieved at any time in the dispatch chain. These
+            values are passed on to the router, dispatcher, and action
+            controllers. The methods include:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>setParam($name, $value)</code> allows you to set a
+                    single parameter of <code>$name</code> with value
+                    <code>$value</code>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>setParams(array $params)</code> allows you to set
+                    multiple parameters at once using an associative array.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>getParam($name)</code> allows you to retrieve a single
+                    parameter at a time, using <code>$name</code> as the
+                    identifier.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>getParams()</code> allows you to retrieve the entire
+                    list of parameters at once.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>clearParams()</code> allows you to clear a single
+                    parameter (by passing a string identifier), multiple named
+                    parameters (by passing an array of string identifiers), or the
+                    entire parameter stack (by passing nothing).
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            There are several pre-defined parameters that may be set that have
+            specific uses in the dispatch chain:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>useDefaultControllerAlways</code> is used to hint to
+                    <link linkend="zend.controller.dispatcher">the
+                        dispatcher</link> to use the default controller in the
+                    default module for any request that is not dispatchable
+                    (i.e., the module, controller, and/or action do not exist).
+                    By default, this is off.
+                </para>
+
+                <para>
+                    See <xref linkend="zend.controller.exceptions.internal" />
+                    for more detailed information on using this setting.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>disableOutputBuffering</code> is used to hint to <link
+                        linkend="zend.controller.dispatcher">the
+                        dispatcher</link> that it should not use output
+                    buffering to capture output generated by action controllers.
+                    By default, the dispatcher captures any output and appends
+                    it to the response object body content.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>noViewRenderer</code> is used to disable the <link
+                        linkend="zend.controller.actionhelpers.viewrenderer">ViewRenderer</link>.
+                    Set this parameter to true to disable it.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <code>noErrorHandler</code> is used to disable the <link
+                        linkend="zend.controller.plugins.standard.errorhandler">Error
+                        Handler plugin</link>. Set this parameter to true to
+                    disable it.
+                </para>
+            </listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.controller.front.subclassing">
+        <title>Extending the Front Controller</title>
+
+        <para>
+            To extend the Front Controller, at the very minimum you will need
+            to override the <code>getInstance()</code> method:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+class My_Controller_Front extends Zend_Controller_Front
+{
+    public static function getInstance()
+    {
+        if (null === self::$_instance) {
+            self::$_instance = new self();
+        }
+
+        return self::$_instance;
+    }
+}
+]]></programlisting>
+
+        <para>
+            Overriding the <code>getInstance()</code> method ensures that
+            subsequent calls to
+            <classname>Zend_Controller_Front::getInstance()</classname> will return an
+            instance of your new subclass instead of a
+            <classname>Zend_Controller_Front</classname> instance -- this is particularly
+            useful for some of the alternate routers and view helpers.
+        </para>
+
+        <para>
+            Typically, you will not need to subclass the front controller unless
+            you need to add new functionality (for instance, a plugin
+            autoloader, or a way to specify action helper paths). Some points
+            where you may want to alter behaviour may include modifying how
+            controller directories are stored, or what default router or
+            dispatcher are used.
+        </para>
+    </sect2>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Controller-Migration.xml

@@ -0,0 +1,733 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Reviewed: no -->
+<sect1 id="zend.controller.migration">
+    <title>Migración de versiones anteriores</title>
+
+    <para>
+    	La API de los componentes de MVC  ha cambiado en el tiempo. Si usted ha empezado a
+    	usar una versión anterior de Zend Framework, sigua la guía de abajo para
+    	migrar sus acripts para usar la arquitectura nueva.
+    </para>
+
+    <sect2 id="zend.controller.migration.fromonesixtooneseven">
+        <title>Migración de 1.6.x a 1.7.0 o nuevas versiones</title>
+
+        <sect3 id="zend.controller.migration.fromonesixtooneseven.dispatcher">
+            <title>El despachador de la interfaz cambios</title>
+
+            <para>
+				Los usuarios llamaron nuestra atención el hecho de que
+                <classname> Zend_Controller_Action_Helper_ViewRenderer </classname> estaba
+                utilizando un método despachador de la clase abstracta que no está en
+                el despachador de la interfaz. Hemos añadido el siguiente método para
+                garantizar que los despachadores de costumbre seguirán trabajando con las
+                implementaciones enviadas:
+            </para>
+
+            <itemizedlist>
+            	<listitem><para>
+                    <code>formatModuleName()</code>: debe utilizarse para tomar un nuevo
+                nombre de controlador, tal como uno que deberia estar basado dentro de una petición
+                objeto, y cambiarlo a un nombre de clase apropiado que la clase extendida
+                <classname>Zend_Controller_Action</classname> deberia usar
+                </para></listitem>
+            </itemizedlist>
+        </sect3>
+    </sect2>
+
+    <sect2 id="zend.controller.migration.fromoneohtoonesix">
+        <title>Migrando desde 1.5.x to 1.6.0 o versiones posteriores</title>
+
+        <sect3 id="zend.controller.migration.fromoneohtoonesix.dispatcher">
+            <title>El Despachador de la Interfaz de cambios</title>
+
+            <para>            		
+				Los usuarios atrajeron nuestra atención con el hecho de que
+                 <classname> Zend_Controller_Front </classname> y
+                 <classname> Zend_Controller_Router_Route_Module </classname> fueron
+                 utilizando métodos del despachador que no estaban en la interfaz del
+                 despachador. Ahora hemos adicionado los siguientes tres métodos para
+                 asegurar que los despachadores diseñados sigan trabajando con las
+                 implementaciones enviadas:
+            </para>
+
+            <itemizedlist>
+                <listitem><para>
+                    <code>getDefaultModule()</code>: debe retornar el nombre del
+                    módulo por defecto.
+                </para></listitem>
+
+                <listitem><para>
+                    <code>getDefaultControllerName()</code>: debe retornar el
+                    nombre del controlador por defecto.
+                </para></listitem>
+
+                <listitem><para>
+                    <code>getDefaultAction()</code>: debe retornar el
+                    nombre de la acción por defecto.
+                </para></listitem>
+            </itemizedlist>
+        </sect3>
+    </sect2>
+
+    <sect2 id="zend.controller.migration.fromoneohtoonefive">
+        <title>Migranado desde 1.0.x a 1.5.0 o versiones posteriores</title>
+
+        <para>        		
+			Aunque la mayoría de la funcionalidad básica sigue siendo la misma, y todas las
+			funcionalidades documentadas siguen siendo la mismas, hay una en particular
+            "característica" <emphasis>undocumented</emphasis> que ha cambiado.
+        </para>
+
+        <para>        		
+			Al escribir las URLs, la manera de escribir la documentada acción camelCased
+            es usar un separador de palabra, que son "." o '-' por defecto,
+            pero pueden ser configurados en el despachador. El despachador internamente
+            convierte en minúsculas el nombre de la acción, y usa estos separadores de palabra para
+            volver a montar el método de la acción camelCasing. Sin embargo, debido a que las
+            funciones de PHP no son sensibles a mayúsculas y minúsculas, usted <emphasis>podría</emphasis>
+            escribir las URLs usando camelCasing, y el despachador los devolvería
+            a la misma ubicación. Por ejemplo, 'camel-cased' se convertirá en
+            'camelCasedAction' por el despachador, mientras que 'camelCased' se
+            convertiría en 'camelCasedAction'; sin embargo, debido a la insensibilidad de
+            PHP, ambos ejecutarán el mismo método.
+        </para>
+
+        <para>        	
+			Esto causa problemas con la vista ViewRenderer cuando devuelve scripts de la
+			vista. El canónico, la documentada forma es que todos los separadores de palabra
+            se conviertan en guiones, y las palabras en minúsculas. Esto crea
+            un lazo semántico entre las acciones y los scripts de las vistas, y la
+            normalización asegura que los scripts puedan ser encontrados. Sin embargo, si la
+            acción "camelCased' es llamada y de hecho retornada, el separador de la palabra
+            no está mas presente, y los ViewRenderer intenta devolver
+            a una ubicación diferente -- 'camelcased.phtml' en vez de
+            'camel-cased.phtml'.
+        </para>
+
+        <para>
+        	Algunos desarrolladores se basarón en esta "característica", que nunca fue la intención.
+            Varios cambios en el árbol 1.5.0 , sin embargo, hizo que la vista
+            ViewRenderer ya no resuelva estas direcciones, la semántica esta ahora
+            forzada. La primera de ellas, el despachador ahora impone
+            la sensibilidad en los nombres de la acción. Lo que esto significa es que la referencia a
+            sus acciones en la url utilisando camelCasing ya no para devolver
+            al mismo método que utilizan los separadores de palabras (es decir, 'camel-casing').
+            Esto nos lleva a la vista ViewRenderer ahora sólo en honor a las acciones
+            palabra-separador cuando se devuleven los scripts vista.
+        </para>
+
+        <para>
+            Si usted nota que estaba dependiendo en esta "caracteristica", usted tiene muchas
+            opciones:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>
+            		Mejor opción: cambiar el nombre de sus scripts de la vistas. Pros:
+                    compatibilidad hacia adelante. Contras: si usted tiene muchos scripts vista que
+                    se basan en la primera vista, una conducta no deseada, tendrá
+                    mucho por hacer.
+            </para></listitem>
+
+            <listitem>
+                <para>                	
+					Segunda mejor opción: La vista ViewRenderer delega ahora resoluciones de scripts
+					de vistas a <classname> Zend_Filter_Inflector </classname>; se puede
+                    modificar las normas del inflector para que ya no separe
+                    las palabras de una acción con un guión:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+$viewRenderer =
+    Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
+$inflector = $viewRenderer->getInflector();
+$inflector->setFilterRule(':action', array(
+    new Zend_Filter_PregReplace(
+        '#[^a-z0-9' . preg_quote(DIRECTORY_SEPARATOR, '#') . ']+#i',
+        ''
+    ),
+    'StringToLower'
+));
+]]></programlisting>
+
+                <para>                		
+					El anterior código modificará el inflector para que ya no
+                    separe las palabras con guión, usted puede querer eliminar
+                    el filtro 'StringToLower' si usted desea<emphasis>hacer</emphasis>
+                    el nombre de script de vista actual camelCased también.
+                </para>
+
+                <para>
+					Si cambiar el nombre del script vista sería demasiado tedioso o tiempo
+                    consumido, esta es su mejor opción hasta que pueda encontrar el
+                    tiempo para hacerlo.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                	La opción menos deseable: Usted puede forzar al despachador para
+                	despachar nombres de acción camelCased con un nuevo controlador
+                    bandera, 'useCaseSensitiveActions':
+                </para>
+
+                <programlisting role="php"><![CDATA[
+$front->setParam('useCaseSensitiveActions', true);
+]]></programlisting>
+
+                <para>
+					Esto le permitirá utilizar camelCasing sobre la url y siguir
+                    tieniendo resuelta la misma acción como cuando se utilizaba los separadores
+                    de palabra. Sin embargo, esto significa que los problemas originales
+                    se iran terminando, lo más probable es utilizar la
+                    segunda opción anterior, además de esto para que las cosas funcionen
+                    confiablemente en todo.
+                </para>
+
+                <para>
+                	Note, también, el uso de esta bandera aumentará un aviso de que
+                	este uso es obsoleto.
+                </para>
+            </listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.controller.migration.fromzeroninethree">
+        <title>Migrando desde 0.9.3 a 1.0.0RC1 o versiones posteriores</title>
+
+        <para>
+        	Los cambios principales introducidos en 1.0.0RC1 son la introducción de
+        	y la activación por defecto del plugin
+			<link
+                linkend="zend.controller.plugins.standard.errorhandler">ErrorHandler</link>
+        	y de acción ayuda <link
+                linkend="zend.controller.actionhelpers.viewrenderer">ViewRenderer</link>
+            Por favor, lea la documentación de cada uno completamente para ver
+            cómo funcionan y qué efecto pueden tener en sus
+            aplicaciones.
+        </para>
+
+        <para>
+        	El plugin <code>ErrorHandler</code> corre durante
+            <code>postDispatch ()</code> para el control de excepciones, y enviarlo
+            a un especifico controlador de errores. Usted debe incluir tal
+            controlador en su aplicación. Usted puede desactivarlo determinando el
+            parámetro del controlador <code> noErrorHandler </code>:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$front->setParam('noErrorHandler', true);
+]]></programlisting>
+
+        <para>
+			La acción de ayuda <code>ViewRenderer</code> automatiza inyección de vistas
+            en controladores de acción así como los autogeneradores de scripts de vistas
+            basados en la acción actual. El principal problema que se puede encontrar es
+            si se tiene acciones que no generan scripts de vista y tampoco llevan
+            o redireccionan, como <code>ViewRenderer</code> intentará generar
+            un scrip de vista basado en el nombre de la acción.
+        </para>
+
+        <para>
+            There are several strategies you can take to update your code. In
+            the short term, you can globally disable the
+            <code>ViewRenderer</code> in your front controller bootstrap prior
+            to dispatching:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+// Assuming $front is an instance of Zend_Controller_Front
+$front->setParam('noViewRenderer', true);
+]]></programlisting>
+
+        <para>
+            However, this is not a good long term strategy, as it means most
+            likely you'll be writing more code.
+        </para>
+
+        <para>
+            When you're ready to start using the <code>ViewRenderer</code>
+            functionality, there are several things to look for in your
+            controller code. First, look at your action methods (the methods
+            ending in 'Action'), and determine what each is doing. If none of
+            the following is happening, you'll need to make changes:
+        </para>
+
+        <itemizedlist>
+            <listitem><para>Calls to <code>$this-&gt;render()</code></para></listitem>
+            <listitem><para>Calls to <code>$this-&gt;_forward()</code></para></listitem>
+            <listitem><para>Calls to <code>$this-&gt;_redirect()</code></para></listitem>
+            <listitem><para>Calls to the <code>Redirector</code> action helper</para></listitem>
+        </itemizedlist>
+
+        <para>
+            The easiest change is to disable auto-rendering for that method:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+$this->_helper->viewRenderer->setNoRender();
+]]></programlisting>
+
+        <para>
+            If you find that none of your action methods are rendering,
+            forwarding, or redirecting, you will likely want to put the above
+            line in your <code>preDispatch()</code> or <code>init()</code>
+            methods:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+public function preDispatch()
+{
+    // disable view script autorendering
+    $this->_helper->viewRenderer->setNoRender()
+    // .. do other things...
+}
+]]></programlisting>
+
+        <para>
+            If you are calling <code>render()</code>, and you're using <link
+                linkend="zend.controller.modular">the Conventional Modular
+                directory structure</link>, you'll want to change your code to
+            make use of autorendering:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    If you're rendering multiple view scripts in a single
+                    action, you don't need to change a thing.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    If you're simply calling <code>render()</code> with no
+                    arguments, you can remove such lines.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    If you're calling <code>render()</code> with arguments, and
+                    not doing any processing afterwards or rendering multiple
+                    view scripts, you can change these calls to read
+                    <code>$this-&gt;_helper-&gt;viewRenderer()</code>.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            If you're not using the conventional modular directory structure,
+            there are a variety of methods for setting the view base path and
+            script path specifications so that you can make use of the
+            <code>ViewRenderer</code>. Please read the <link
+                linkend="zend.controller.actionhelpers.viewrenderer">ViewRenderer
+                documentation</link> for information on these methods.
+        </para>
+
+        <para>
+            If you're using a view object from the registry, or customizing your
+            view object, or using a different view implementation, you'll want
+            to inject the <code>ViewRenderer</code> with this object. This can
+            be done easily at any time.
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    Prior to dispatching a front controller instance:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+// Assuming $view has already been defined
+$viewRenderer = new Zend_Controller_Action_Helper_ViewRenderer($view);
+Zend_Controller_Action_HelperBroker::addHelper($viewRenderer);
+]]></programlisting>
+            </listitem>
+
+            <listitem>
+                <para>
+                    Any time during the bootstrap process:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+$viewRenderer =
+    Zend_Controller_Action_HelperBroker::getStaticHelper('viewRenderer');
+$viewRenderer->setView($view);
+]]></programlisting>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            There are many ways to modify the <code>ViewRenderer</code>,
+            including setting a different view script to render, specifying
+            replacements for all replaceable elements of a view script path
+            (including the suffix), choosing a response named segment to
+            utilize, and more. If you aren't using the conventional modular
+            directory structure, you can even associate different path
+            specifications with the <code>ViewRenderer</code>.
+        </para>
+
+        <para>
+            We encourage you to adapt your code to use the
+            <code>ErrorHandler</code> and <code>ViewRenderer</code> as they are
+            now core functionality.
+        </para>
+    </sect2>
+
+    <sect2 id="zend.controller.migration.fromzeroninetwo">
+        <title>Migrating from 0.9.2 to 0.9.3 or Newer</title>
+
+        <para>
+            0.9.3 introduces <link
+                linkend="zend.controller.actionhelpers">action helpers</link>.
+            As part of this change, the following methods have been removed as
+            they are now encapsulated in the <link
+                linkend="zend.controller.actionhelpers.redirector">redirector
+                action helper</link>:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <code>setRedirectCode()</code>; use
+                    <classname>Zend_Controller_Action_Helper_Redirector::setCode()</classname>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    <code>setRedirectPrependBase()</code>; use
+                    <classname>Zend_Controller_Action_Helper_Redirector::setPrependBase()</classname>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    <code>setRedirectExit()</code>; use
+                    <classname>Zend_Controller_Action_Helper_Redirector::setExit()</classname>.
+                </para>
+            </listitem>
+        </itemizedlist>
+
+        <para>
+            Read the <link linkend="zend.controller.actionhelpers">action
+                helpers documentation</link> for more information on how to
+            retrieve and manipulate helper objects, and the <link
+                linkend="zend.controller.actionhelpers.redirector">redirector
+                helper documentation</link> for more information on setting
+            redirect options (as well as alternate methods for redirecting).
+        </para>
+    </sect2>
+
+    <sect2 id="zend.controller.migration.fromzerosix">
+        <title>Migrating from 0.6.0 to 0.8.0 or Newer</title>
+
+        <para>
+            Per previous changes, the most basic usage of the MVC components
+            remains the same:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+Zend_Controller_Front::run('/path/to/controllers');
+]]></programlisting>
+
+        <para>
+            However, the directory structure underwent an overhaul, several
+            components were removed, and several others either renamed or added.
+            Changes include:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Router</classname> was removed in favor of
+                    the rewrite router.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_RewriteRouter</classname> was renamed to
+                    <classname>Zend_Controller_Router_Rewrite</classname>, and promoted to
+                    the standard router shipped with the framework;
+                    <classname>Zend_Controller_Front</classname> will use it by default if
+                    no other router is supplied.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    A new route class for use with the rewrite router was
+                    introduced,
+                    <classname>Zend_Controller_Router_Route_Module</classname>; it covers
+                    the default route used by the MVC, and has support for <link
+                        linkend="zend.controller.modular">controller
+                        modules</link>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Router_StaticRoute</classname> was renamed
+                    to <classname>Zend_Controller_Router_Route_Static</classname>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Dispatcher</classname> was renamed
+                    <classname>Zend_Controller_Dispatcher_Standard</classname>.
+                </para>
+            </listitem>
+
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Action::_forward()</classname>'s arguments
+                    have changed. The signature is now:
+                </para>
+
+                <programlisting role="php"><![CDATA[
+final protected function _forward($action,
+                                  $controller = null,
+                                  $module = null,
+                                  array $params = null);
+]]></programlisting>
+
+                <para>
+                    <code>$action</code> is always required; if no controller is
+                    specified, an action in the current controller is assumed.
+                    <code>$module</code> is always ignored unless
+                    <code>$controller</code> is specified. Finally, any
+                    <code>$params</code> provided will be appended to the
+                    request object. If you do not require the controller or
+                    module, but still need to pass parameters, simply specify
+                    null for those values.
+                </para>
+            </listitem>
+        </itemizedlist>
+    </sect2>
+
+    <sect2 id="zend.controller.migration.fromzerotwo">
+        <title>Migrating from 0.2.0 or before to 0.6.0</title>
+
+        <para>
+            The most basic usage of the MVC components has not changed; you can
+            still do each of the following:
+        </para>
+
+        <programlisting role="php"><![CDATA[
+Zend_Controller_Front::run('/path/to/controllers');
+]]></programlisting>
+
+        <programlisting role="php"><![CDATA[
+/* -- create a router -- */
+$router = new Zend_Controller_RewriteRouter();
+$router->addRoute('user',
+                  'user/:username',
+                  array('controller' => 'user', 'action' => 'info')
+);
+
+/* -- set it in a controller -- */
+$ctrl = Zend_Controller_Front::getInstance();
+$ctrl->setRouter($router);
+
+/* -- set controller directory and dispatch -- */
+$ctrl->setControllerDirectory('/path/to/controllers');
+$ctrl->dispatch();
+]]></programlisting>
+
+        <para>
+            We encourage use of the Response object to aggregate content and
+            headers. This will allow for more flexible output format switching
+            (for instance, JSON or XML instead of XHTML) in your applications.
+            By default, <code>dispatch()</code> will render the response, sending both
+            headers and rendering any content. You may also have the front
+            controller return the response using <code>returnResponse()</code>,
+            and then render the response using your own logic. A future version
+            of the front controller may enforce use of the response object via
+            output buffering.
+        </para>
+
+        <para>
+            There are many additional features that extend the existing API,
+            and these are noted in the documentation.
+        </para>
+
+        <para>
+            The main changes you will need to be aware of will be found when
+            subclassing the various components. Key amongst these are:
+        </para>
+
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <classname>Zend_Controller_Front::dispatch()</classname> by default
+                    traps exceptions in the response object, and does not render
+                    them, in order to prevent sensitive system information from
+                    being rendered. You can override this in several ways:
+                </para>
+
+                <itemizedlist>
+                    <listitem>
+                        <para>
+                            Set <code>throwExceptions()</code> in the front
+                            controller:
+                        </para>
+                        <programlisting role="php"><![CDATA[
+$front->throwExceptions(true);
+]]></programlisting>
+                    </listitem>
+
+                    <listitem>
+                        <para>
+                            Set <code>renderExceptions()</code> in the response
+                            object:
+                        </para>
+                        <programlisting role="php"><![CDATA[
+$response->renderExceptions(true);
+$front->setResponse($response);
+$front->dispatch();
+
+// or:
+$front->returnResponse(true);
+$response = $front->dispatch();
+$response->renderExceptions(true);
+echo $response;
+]]></programlisting>
+                    </listitem>
+                </itemizedlist>
+            </listitem>
+
+            <listitem><para>
+                <classname>Zend_Controller_Dispatcher_Interface::dispatch()</classname>
+                now accepts and returns a <xref linkend="zend.controller.request" />
+                object instead of a dispatcher token.
+            </para></listitem>
+
+            <listitem><para>
+                <classname>Zend_Controller_Router_Interface::route()</classname>
+                now accepts and returns a <xref linkend="zend.controller.request" />
+                object instead of a dispatcher token.
+            </para></listitem>
+
+            <listitem>
+                <para><classname>Zend_Controller_Action</classname> changes include:</para>
+
+                <itemizedlist>
+                    <listitem><para>
+                        The constructor now accepts exactly three arguments,
+                        <classname>Zend_Controller_Request_Abstract $request</classname>,
+                        <classname>Zend_Controller_Response_Abstract $response</classname>,
+                        and <code>array $params (optional)</code>.
+                        <classname>Zend_Controller_Action::__construct()</classname> uses
+                        these to set the request, response, and invokeArgs
+                        properties of the object, and if overriding the
+                        constructor, you should do so as well. Better yet, use
+                        the <code>init()</code> method to do any instance
+                        configuration, as this method is called as the final
+                        action of the constructor.
+                    </para></listitem>
+
+                    <listitem><para>
+                        <code>run()</code> is no longer defined as final, but is
+                        also no longer used by the front controller; its sole
+                        purpose is for using the class as a page controller. It
+                        now takes two optional arguments, a
+                        <classname>Zend_Controller_Request_Abstract $request</classname>
+                        and a <classname>Zend_Controller_Response_Abstract $response</classname>.
+                    </para></listitem>
+
+                    <listitem><para>
+                        <code>indexAction()</code> no longer needs to be
+                        defined, but is encouraged as the default action. This
+                        allows using the RewriteRouter and action controllers to
+                        specify different default action methods.
+                    </para></listitem>
+
+                    <listitem><para>
+                        <code>__call()</code> should be overridden to handle any
+                        undefined actions automatically.
+                    </para></listitem>
+
+                    <listitem><para>
+                        <code>_redirect()</code> now takes an optional second
+                        argument, the HTTP code to return with the redirect, and
+                        an optional third argument, <code>$prependBase</code>,
+                        that can indicate that the base URL registered with the
+                        request object should be prepended to the url specified.
+                    </para></listitem>
+
+                    <listitem>
+                        <para>
+                            The <code>_action</code> property is no longer set.
+                            This property was a <classname>Zend_Controller_Dispatcher_Token</classname>,
+                            which no longer exists in the current incarnation.
+                            The sole purpose of the token was to provide
+                            information about the requested controller, action,
+                            and URL parameters. This information is now
+                            available in the request object, and can be accessed
+                            as follows:
+                        </para>
+
+                        <programlisting role="php"><![CDATA[
+// Retrieve the requested controller name
+// Access used to be via: $this->_action->getControllerName().
+// The example below uses getRequest(), though you may also directly
+// access the $_request property; using getRequest() is recommended as
+// a parent class may override access to the request object.
+$controller = $this->getRequest()->getControllerName();
+
+// Retrieve the requested action name
+// Access used to be via: $this->_action->getActionName().
+$action = $this->getRequest()->getActionName();
+
+// Retrieve the request parameters
+// This hasn't changed; the _getParams() and _getParam() methods simply
+// proxy to the request object now.
+$params = $this->_getParams();
+// request 'foo' parameter, using 'default' as default value if not found
+$foo = $this->_getParam('foo', 'default');
+]]></programlisting>
+                    </listitem>
+
+                    <listitem>
+                        <para>
+                            <code>noRouteAction()</code> has been removed. The
+                            appropriate way to handle non-existent action
+                            methods should you wish to route them to a default
+                            action is using <code>__call()</code>:
+                        </para>
+
+                        <programlisting role="php"><![CDATA[
+public function __call($method, $args)
+{
+    // If an unmatched 'Action' method was requested, pass on to the
+    // default action method:
+    if ('Action' == substr($method, -6)) {
+        return $this->defaultAction();
+    }
+
+    throw new Zend_Controller_Exception('Invalid method called');
+}
+]]></programlisting>
+                    </listitem>
+                </itemizedlist>
+            </listitem>
+
+            <listitem><para>
+                <classname>Zend_Controller_RewriteRouter::setRewriteBase()</classname> has
+                been removed. Use <classname>Zend_Controller_Front::setBaseUrl()</classname>
+                instead (or <classname>Zend_Controller_Request_Http::setBaseUrl()</classname>, if using
+                that request class).
+            </para></listitem>
+
+            <listitem><para>
+                <classname>Zend_Controller_Plugin_Interface</classname> was replaced
+                by <classname>Zend_Controller_Plugin_Abstract</classname>. All methods now
+                accept and return a <xref linkend="zend.controller.request" />
+                object instead of a dispatcher token.
+            </para></listitem>
+        </itemizedlist>
+    </sect2>
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->

documentation/manual/es/module_specs/Zend_Date-Overview.xml

@@ -0,0 +1,856 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- EN-Revision: 15103 -->
+<!-- Reviewed: no -->
+<sect1 id="zend.date.overview">
+
+    <title>Zend_Date API Overview</title>
+
+    <para>
+        Mientras la API <classname>Zend_Date</classname> permanece simple y unitaria, el diseo permanece flexible y poderoso
+        a travs de las permiutaciones de operaciones y operandos.
+    </para>
+
+    <sect2 id="zend.date.options">
+
+        <title>Opciones Zend_Date</title>
+
+        <sect3 id="zend.date.options.formattype">
+
+            <title>seleccionando el tipo de formato de la fecha</title>
+
+            <para>
+                Several methods use date format strings, in a way similar to PHP's <code>date()</code>.
+                If you are more comfortable with PHP's date format specifier than with ISO format specifiers,
+                then you can use <classname>Zend_Date::setOptions(array('format_type' => 'php'))</classname>.
+                Afterward, use PHP's date format specifiers for all functions which accept a <code>$format</code> parameter.
+                Use <classname>Zend_Date::setOptions(array('format_type' => 'iso'))</classname> to switch back to the default mode of
+                supporting only ISO date format tokens. For a list of supported format codes, see
+                <xref linkend="zend.date.constants.phpformats" />
+            </para>
+
+        </sect3>
+
+        <sect3 id="zend.date.options.fixdst">
+
+            <title>DST and Date Math</title>
+
+            <para>
+                When dates are manipulated, sometimes they cross over a DST change, normally resulting in the date
+                losing or gaining an hour.  For exmaple, when adding months to a date before a DST change, if the
+                resulting date is after the DST change, then the resulting date will appear to lose or gain an hour,
+                resulting in the time value of the date changing.  For boundary dates, such as midnight of the first
+                or last day of a month, adding enough months to cross a date boundary results in the date losing
+                an hour and becoming the last hour of the preceding month, giving the appearance of an "off by 1"
+                error.  To avoid this situation, the DST change ignored by using the <code>fix_dst</code> option.
+                When crossing the Summer/Winter DST boundary, normally an hour is substracted or added depending
+                on the date.  For example, date math crossing the Spring DST leads to a date having a day value
+                one less than expected, if the time part of the date was originally 00:00:00.  Since Zend_Date
+                is based on timestamps, and not calendar dates with a time component, the timestamp loses an hour,
+                resulting in the date having a calendar day value one less than expected.
+                To prevent such problems use the option <code>fix_dst</code>, which defaults to true, causing DST
+                to have no effect on date "math" (<code>addMOnth(), subMonth()</code>). Use
+                <classname>Zend_Date::setOptions(array('fix_dst' => false))</classname> to enable the subtraction or addition
+                of the DST adjustment when performing date "math".
+            </para>
+
+            <para>
+                <emphasis>If your actual timezone within the instance of <classname>Zend_Date</classname>
+                is set to UTC or GMT the option <code>'fix_dst'</code> will not be used</emphasis> because
+                these two timezones do not work with DST. When you change the timezone for this instance
+                again to a timezone which is not UTC or GMT the previous set 'fix_dst' option will be used
+                again for date "math".
+            </para>
+        </sect3>
+
+        <sect3 id="zend.date.options.extendmonth">
+
+            <title>Month Calculations</title>
+
+            <para>
+                When adding or substracting months from an existing date, the resulting value for the day of
+                the month might be unexpected, if the original date fell on a day close to the end of the month.
+                For example, when adding one month to January 31st, people familiar with SQL will expect February
+                28th as the result. On the other side, people familiar with Excel and OpenOffice will expect
+                March 3rd as the result. The problem only occurs, if the resulting month does not have the day,
+                which is set in the original date.  For ZF developers, the desired behavior is selectable using
+                the <code>extend_month</code> option to choose either the SQL behaviour, if set to false,
+                or the spreadsheet behaviour when set to true. The default behaviour for <code>extend_month</code>
+                is false, providing behavior compatible to SQL.  By default, <classname>Zend_Date</classname> computes month
+                calculations by truncating dates to the end of the month (if necessary), without wrapping into the
+                next month when the original date designates a day of the month exceeding the number of days in
+                the resulting month.  Use <classname>Zend_Date::setOptions(array('extend_month' => true));</classname>
+                to make month calculations work like popular spreadsheet programs.
+            </para>
+
+        </sect3>
+
+        <sect3 id="zend.date.options.cache">
+
+            <title>Speed up Date Localization and Normalization with Zend_Cache</title>
+
+            <para>
+                You can speed up <classname>Zend_Date</classname> by using an <classname>Zend_Cache</classname> adapter.
+                This speeds up all methods of <classname>Zend_Date</classname> when you are using localized data.
+                For example all methods which accept <classname>Zend_Date::DATE</classname> and
+                <classname>Zend_Date::TIME</classname> constants would benefit from this. To set an <classname>Zend_Cache</classname>
+                adapter to <classname>Zend_Date</classname> just use
+                <classname>Zend_Date::setOptions(array('cache' => $adapter));</classname>.
+            </para>
+
+        </sect3>
+
+        <sect3 id="zend.date.options.timesync">
+
+            <title>Receiving Syncronised Timestamps with Zend_TimeSync</title>
+
+            <para>
+                Normally the clocks from servers and computers differ from each other. <classname>Zend_Date</classname>
+                is able to handle such problems with the help of <classname>Zend_TimeSync</classname>. You can set a
+                timeserver with <classname>Zend_Date::setOptions(array('timesync' => $timeserver));</classname> which
+                will set the offset between the own actual timestamp and the real actual timestamp for all
+                instances of Zend_Date. Using this option does not change the timestamp of existing instances.
+                So best usage is to set it within the bootstrap file.
+            </para>
+
+        </sect3>
+
+    </sect2>
+
+    <sect2 id="zend.date.values">
+
+        <title>Working with Date Values</title>
+
+        <para>
+            Once input has been normalized via the creation of a <classname>Zend_Date</classname> object, it will have an
+            associated timezone, but an internal representation using standard
+            <ulink url="http://en.wikipedia.org/wiki/Unix_Time">UNIX timestamps</ulink>
+            . In order for a date to be rendered in a localized manner, a timezone must be known first. The default
+            timezone is always GMT/UTC. To examine an object's timezone use <code>getTimeZone())</code>. To change an
+            object's timezone, use <code>setTimeZone())</code>. All manipulations of these objects are assumed to be
+            relative to this timezone.
+        </para>
+
+        <para>
+            Beware of mixing and matching operations with date parts between date objects for different timezones, which
+            generally produce undesireable results, unless the manipulations are only related to the timestamp.
+            Operating on <classname>Zend_Date</classname> objects having different timezones generally works, except as just
+            noted, since dates are normalized to UNIX timestamps on instantiation of <classname>Zend_Date</classname>.
+        </para>
+
+        <para>
+            Most methods expect a constant selecting the desired <code>$part</code> of a date, such as
+            <classname>Zend_Date::HOUR</classname>. These constants are valid for all of the functions below. A list of all
+            available constants is provided in
+            <xref linkend="zend.date.constants.list" />
+            . If no <code>$part</code> is specified, then <classname>Zend_Date::TIMESTAMP</classname> is assumed. Alternatively, a
+            user-specified format may be used for <code>$part</code>, using the same underlying mechanism and format
+            codes as
+            <link linkend="zend.locale.date.normalize"><classname>Zend_Locale_Format::getDate()</classname>
+            </link>
+            . If a date object is constructed using an obviously invalid date (e.g. a month number greater than 12),
+            then <classname>Zend_Date</classname> will throw an exception, unless no specific date format has been selected -i.e.
+            <code>$part</code> is either <code>null</code> or <classname>Zend_Date::DATES</classname> (a "loose" format).
+        </para>
+
+        <example id="zend.date.values.example-1">
+            <title>User-Specified Input Date Format</title>
+            <programlisting role="php"><![CDATA[
+$date1 = new Zend_Date('Feb 31, 2007', null, 'en_US');
+echo $date1, "\n"; // outputs "Mar 3, 2007 12:00:00 AM"
+
+$date2 = new Zend_Date('Feb 31, 2007', Zend_Date::DATES, 'en_US');
+echo $date2, "\n"; // outputs "Mar 3, 2007 12:00:00 AM"
+
+// strictly restricts interpretation to specified format
+$date3 = new Zend_Date('Feb 31, 2007', 'MM.dd.yyyy');
+echo $date3, "\n"; // outputs "Mar 3, 2007 12:00:00 AM"
+]]></programlisting>
+        </example>
+
+        <para>
+            If the optional <code>$locale</code> parameter is provided, then the <code>$locale</code> disambiguates the
+            <code>$date</code> operand by replacing month and weekday names for string <code>$date</code> operands, and
+            even parsing date strings expressed according to the conventions of that locale (see <code>
+            <link linkend="zend.locale.date.normalize">Zend_Locale_Format::getDate()</link>
+            </code> ). The automatic normalization of localized <code>$date</code> operands of a string type occurs when
+            <code>$part</code> is one of the <classname>Zend_Date::DATE*</classname> or <classname>Zend_Date::TIME*</classname> constants.
+            The locale identifies which language should be used to parse month names and weekday names, if the
+            <code>$date</code> is a string containing a date. If there is no <code>$date</code> input parameter, then
+            the <code>$locale</code> parameter specifies the locale to use for localizing output (e.g. the date format
+            for a string representation). Note that the <code>$date</code> input parameter might actually have a type
+            name instead (e.g. <code>$hour</code> for <code>addHour()</code>), although that does not prevent the use of
+            <classname>Zend_Date</classname> objects as arguments for that parameter. If no <code>$locale</code> was specified,
+            then the locale of the current object is used to interpret <code>$date</code>, or select the localized
+            format for output.
+        </para>
+
+        <para>
+            Since Zend Framework 1.7.0 <classname>Zend_Date</classname> does also support the usage of an application
+            wide locale. You can simply set a <classname>Zend_Locale</classname> instance to the registry like shown
+            below. With this notation you can forget about setting the locale manually with each instance when
+            you want to use the same locale multiple times.
+        </para>
+
+        <programlisting role="php"><![CDATA[
+// in your bootstrap file
+$locale = new Zend_Locale('de_AT');
+Zend_Registry::set('Zend_Locale', $locale);
+
+// somewhere in your application
+$date = new Zend_Date('31.Feb.2007');
+]]></programlisting>
+
+    </sect2>
+
+    <sect2 id="id.date.basic">
+
+        <title>Basic <classname>Zend_Date</classname> Operations Common to Many Date Parts</title>
+
+        <para>
+            The methods <code>add(), sub(), compare(), get(), and set()</code> operate generically on dates. In each
+            case, the operation is performed on the date held in the instance object. The <code>$date</code> operand is
+            required for all of these methods, except <code>get()</code>, and may be a <classname>Zend_Date</classname> instance
+            object, a numeric string, or an integer. These methods assume <code>$date</code> is a timestamp, if it is
+            not an object. However, the <code>$part</code> operand controls which logical part of the two dates are
+            operated on, allowing operations on parts of the object's date, such as year or minute, even when
+            <code>$date</code> contains a long form date string, such as, "December 31, 2007 23:59:59". The result of
+            the operation changes the date in the object, except for <code>compare()</code>, and <code>get()</code>.
+        </para>
+
+        <example id="zend.date.basic.example-1">
+            <title>Operating on Parts of Dates</title>
+            <programlisting role="php"><![CDATA[
+$date = new Zend_Date(); // $date's timestamp === time()
+
+// changes $date by adding 12 hours
+$date->add('12', Zend_Date::HOUR);
+print $date;
+]]></programlisting>
+        </example>
+
+        <para>
+            Convenience methods exist for each combination of the basic operations and several common date parts as
+            shown in the tables below. These convenience methods help us lazy programmers avoid having to type out the
+            <link linkend="zend.date.constants.list">date part constants</link>
+            when using the general methods above. Conveniently, they are named by combining a prefix (name of a basic
+            operation) with a suffix (type of date part), such as <code>addYear()</code>. In the list below, all
+            combinations of "Date Parts" and "Basic Operations" exist. For example, the operation "add" exists for each
+            of these date parts, including <code>addDay()</code>, <code>addYear()</code>, etc.
+        </para>
+
+        <para>
+            These convenience methods have the same equivalent functionality as the basic operation methods, but expect
+            string and integer <code>$date</code> operands containing only the values representing the type indicated by
+            the suffix of the convenience method. Thus, the names of these methods (e.g. "Year" or "Minute") identify
+            the units of the <code>$date</code> operand, when <code>$date</code> is a string or integer.
+        </para>
+
+        <sect3 id="id.date.basic.parts">
+
+            <title>List of Date Parts</title>
+
+            <table id="id.date.basic.parts.table">
+                <title>Date Parts</title>
+                <tgroup cols="2">
+                    <thead>
+                        <row>
+                            <entry>Date Part</entry>
+                            <entry>Explanation</entry>
+                        </row>
+                    </thead>
+                    <tbody>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/Unix_Time">Timestamp</ulink>
+                            </entry>
+                            <entry>
+                            UNIX timestamp, expressed in seconds elapsed since January 1st, 1970 00:00:00 GMT/UTC.
+                        </entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/Gregorian_calendar">Year</ulink>
+                            </entry>
+                            <entry>Gregorian calendar year (e.g. 2006)</entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/Month#Julian_and_Gregorian_calendars">Month</ulink>
+                            </entry>
+                            <entry>Gregorian calendar month (1-12, localized names supported)</entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/24-hour_clock">24 hour clock</ulink>
+                            </entry>
+                            <entry>Hours of the day (0-23) denote the hours elapsed, since the start of the day.</entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/Minute">minute</ulink>
+                            </entry>
+                            <entry>Minutes of the hour (0-59) denote minutes elapsed, since the start of the hour.</entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/Second">Second</ulink>
+                            </entry>
+                            <entry>Seconds of the minute (0-59) denote the elapsed seconds, since the start of the minute.</entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/Millisecond">millisecond</ulink>
+                            </entry>
+                            <entry>Milliseconds denote thousandths of a second (0-999). <classname>Zend_Date</classname> supports two additional methods for working with time units smaller than seconds. By default, <classname>Zend_Date</classname> instances use a precision defaulting to milliseconds, as seen using <code>getFractionalPrecision()</code>. To change the precision use <code>setFractionalPrecision($precision)</code>.  However, precision is limited practically to microseconds, since <classname>Zend_Date</classname> uses <code>
+                                <ulink url="http://php.net/microtime">microtime()</ulink></code>.</entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/Day">Day</ulink>
+                            </entry>
+                            <entry><classname>Zend_Date::DAY_SHORT</classname> is extracted from <code>$date</code> if the <code>$date</code> operand is an instance of <classname>Zend_Date</classname> or a numeric string.  Otherwise, an attempt is made to extract the day according to the conventions documented for these constants: <classname>Zend_Date::WEEKDAY_NARROW</classname>, <classname>Zend_Date::WEEKDAY_NAME</classname>, <classname>Zend_Date::WEEKDAY_SHORT</classname>, <classname>Zend_Date::WEEKDAY</classname> (Gregorian calendar assumed)</entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/Week">Week</ulink>
+                            </entry>
+                            <entry><classname>Zend_Date::WEEK</classname> is extracted from <code>$date</code> if the <code>$date</code> operand is an instance of <classname>Zend_Date</classname> or a numeric string. Otherwise an exception is raised. (Gregorian calendar assumed)</entry>
+                        </row>
+                        <row>
+                            <entry>Date</entry>
+                            <entry><classname>Zend_Date::DAY_MEDIUM</classname> is extracted from <code>$date</code> if the <code>$date</code> operand is an instance of <classname>Zend_Date</classname>.  Otherwise, an attempt is made to normalize the <code>$date</code> string into a Zend_Date::DATE_MEDIUM formatted date. The format of <classname>Zend_Date::DAY_MEDIUM</classname> depends on the object's locale.</entry>
+                        </row>
+                        <row>
+                            <entry>Weekday</entry>
+                            <entry>Weekdays are represented numerically as 0 (for Sunday) through 6 (for Saturday).  <classname>Zend_Date::WEEKDAY_DIGIT</classname> is extracted from <code>$date</code>, if the <code>$date</code> operand is an instance of <classname>Zend_Date</classname> or a numeric string.  Otherwise, an attempt is made to extract the day according to the conventions documented for these constants: <classname>Zend_Date::WEEKDAY_NARROW</classname>, <classname>Zend_Date::WEEKDAY_NAME</classname>, <classname>Zend_Date::WEEKDAY_SHORT</classname>, <classname>Zend_Date::WEEKDAY</classname> (Gregorian calendar assumed)</entry>
+                        </row>
+                        <row>
+                            <entry>DayOfYear</entry>
+                            <entry>In <classname>Zend_Date</classname>, the day of the year represents the number of calendar days elapsed since the start of the year (0-365).  As with other units above, fractions are rounded down to the nearest whole number. (Gregorian calendar assumed)
+                        </entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://www.faqs.org/rfcs/rfc822.html">Arpa</ulink>
+                            </entry>
+                            <entry>Arpa dates (i.e. RFC 822 formatted dates) are supported. Output uses either a "GMT" or "Local differential hours+min" format (see section 5 of RFC 822).  Before PHP 5.2.2, using the DATE_RFC822 constant with PHP date functions sometimes produces <ulink url="http://bugs.php.net/bug.php?id=40308">incorrect results</ulink>.  Zend_Date's results are correct.  Example: <code>Mon, 31 Dec 06 23:59:59 GMT</code>
+                            </entry>
+                        </row>
+                        <row>
+                            <entry>
+                                <ulink url="http://en.wikipedia.org/wiki/ISO_8601">Iso</ulink>
+                            </entry>
+                            <entry>Only complete ISO 8601 dates are supported for output. Example: <code>2009-02-14T00:31:30+01:00</code>
+                            </entry>
+                        </row>
+                    </tbody>
+                </tgroup>
+            </table>
+
+        </sect3>
+
+        <sect3 id="id.date.basic.operations">
+
+            <title>List of Date Operations</title>
+
+            <para>
+                The basic operations below can be used instead of the convenience operations for specific date parts, if
+                the
+                <link linkend="zend.date.constants.list">appropriate constant</link>
+                is used for the <code>$part</code> parameter.
+            </para>
+
+            <table id="id.date.basic.operations.table">
+                <title>Basic Operations</title>
+                <tgroup cols="2">
+                    <thead>
+                        <row>
+                            <entry>Basic Operation</entry>
+                            <entry>Explanation</entry>
+                        </row>
+                    </thead>
+                    <tbody>
+                        <row>
+                            <entry>get()</entry>
+                            <entry>
+                                <para>
+                                    <emphasis>get($part = null, $locale = null)</emphasis>
+                                </para>
+                                <para>
+                                    Use <code>get($part)</code> to retrieve the date <code>$part</code> of this object's
+                                    date localized to <code>$locale</code> as a formatted string or integer. When using
+                                    the BCMath extension, numeric strings might be returned instead of integers for
+                                    large values. <emphasis>NOTE:</emphasis> Unlike <code>get()</code>,
+                                    the other get*() convenience methods only return instances of <classname>Zend_Date</classname>
+                                    containing a date representing the selected or computed date/time.
+                                </para>
+                            </entry>
+                        </row>
+                        <row>
+                            <entry>set()</entry>
+                            <entry>
+                                <para>
+                                    <emphasis>set($date, $part = null, $locale = null)</emphasis>
+                                </para>
+                                <para>
+                                    Sets the <code>$part</code> of the current object to the corresponding value for
+                                    that part found in the input <code>$date</code> having a locale
+                                    <code>$locale</code>.
+                                </para>
+                            </entry>
+                        </row>
+                        <row>
+                            <entry>add()</entry>
+                            <entry>
+                                <para>
+                                    <emphasis>add($date, $part = null, $locale = null)</emphasis>
+                                </para>
+                                <para>
+                                    Adds the <code>$part</code> of <code>$date</code> having a locale
+                                    <code>$locale</code> to the current object's date.
+                                </para>
+                            </entry>
+                        </row>
+                        <row>
+                            <entry>sub()</entry>
+                            <entry>
+                                <para>
+                                    <emphasis>sub($date, $part = null, $locale = null)</emphasis>
+                                </para>
+                                <para>
+                                    Subtracts the <code>$part</code> of <code>$date</code> having a locale
+                                    <code>$locale</code> from the current object's date.
+                                </para>
+                            </entry>
+                        </row>
+                        <row>
+                            <entry>copyPart()</entry>
+                            <entry>
+                                <para>
+                                    <emphasis>copyPart($part, $locale = null)</emphasis>
+                                </para>
+                                <para>
+                                    Returns a cloned object, with only <code>$part</code> of the object's date copied to
+                                    the clone, with the clone have its locale arbitrarily set to <code>$locale</code>
+                                    (if specified).
+                                </para>
+                            </entry>
+                        </row>
+                        <row>
+                            <entry>compare()</entry>
+                            <entry>
+                                <para>
+                                    <emphasis>compare($date, $part = null, $locale = null)</emphasis>
+                                </para>
+                                <para>
+                                    compares <code>$part</code> of <code>$date</code> to this object's timestamp,
+                                    returning 0 if they are equal, 1 if this object's part was more recent than $date's
+                                    part, otherwise -1.
+                                </para>
+                            </entry>
+                        </row>
+                    </tbody>
+                </tgroup>
+            </table>
+
+        </sect3>
+
+    </sect2>
+
+    <sect2 id="zend.date.others.comparison">
+
+        <title>Comparing Dates</title>
+
+        <para>
+            The following basic operations do not have corresponding convenience methods for the date parts listed in
+            <xref linkend="zend.date.overview" />
+            .
+        </para>
+
+        <table id="zend.date.others.comparison.table">
+            <title>Date Comparison Methods</title>
+            <tgroup cols="2">
+                <thead>
+                    <row>
+                        <entry>Method</entry>
+                        <entry>Explanation</entry>
+                    </row>
+                </thead>
+                <tbody>
+                    <row>
+                        <entry>equals()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>equals($date, $part = null, $locale = null)</emphasis>
+                            </para>
+                            <para>
+                                returns true, if <code>$part</code> of <code>$date</code> having locale
+                                <code>$locale</code> is the same as this object's date <code>$part</code>, otherwise
+                                false
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>isEarlier()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>isEarlier($date, $part = null, $locale = null)</emphasis>
+                            </para>
+                            <para>
+                                returns true, if <code>$part</code> of this object's date is earlier than
+                                <code>$part</code> of <code>$date</code> having a locale <code>$locale</code>
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>isLater()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>isLater($date, $part = null, $locale = null)</emphasis>
+                            </para>
+                            <para>
+                                returns true, if <code>$part</code> of this object's date is later than
+                                <code>$part</code> of <code>$date</code> having a locale <code>$locale</code>
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>isToday()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>isToday()</emphasis>
+                            </para>
+                            <para>
+                                Tests if today's year, month, and day match this object's date value, using this
+                                object's timezone.
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>isTomorrow()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>isTomorrow()</emphasis>
+                            </para>
+                            <para>
+                                Tests if tomorrow's year, month, and day match this object's date value, using this
+                                object's timezone.
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>isYesterday()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>isYesterday()</emphasis>
+                            </para>
+                            <para>
+                                Tests if yesterday's year, month, and day match this object's date value, using this
+                                object's timezone.
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>isLeapYear()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>isLeapYear()</emphasis>
+                            </para>
+                            <para>
+                                Use <code>isLeapYear()</code> to determine if the current object is a leap year, or use
+                                Zend_Date::checkLeapYear($year) to check $year, which can be a string, integer, or
+                                instance of <classname>Zend_Date</classname>. Is the year a leap year?
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>isDate()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>isDate($date, $format = null, $locale = null)</emphasis>
+                            </para>
+                            <para>
+                                This method checks if a given date is a real date and returns true if all checks are ok.
+                                It works like PHP's checkdate() function but can also check for localized month names and
+                                for dates extending the range of checkdate()
+                                false
+                            </para>
+                        </entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
+
+    </sect2>
+
+    <sect2 id="zend.date.others.gettingparts">
+
+        <title>Getting Dates and Date Parts</title>
+
+        <para>
+            Several methods support retrieving values related to a <classname>Zend_Date</classname> instance.
+        </para>
+
+        <table id="zend.date.others.gettingparts.table">
+            <title>Date Output Methods</title>
+            <tgroup cols="2">
+                <thead>
+                    <row>
+                        <entry>Method</entry>
+                        <entry>Explanation</entry>
+                    </row>
+                </thead>
+                <tbody>
+                    <row>
+                        <entry>toString()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>toString($format = null, $locale = null)</emphasis>
+                            </para>
+                            <para>
+                                Invoke directly or via the magic method <code>__toString()</code>. The
+                                <code>toString()</code> method automatically formats the date object's value according
+                                to the conventions of the object's locale, or an optionally specified
+                                <code>$locale</code>. For a list of supported format codes, see
+                                <xref linkend="zend.date.constants.selfdefinedformats" />
+                                .
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>toArray()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>toArray()</emphasis>
+                            </para>
+                            <para>
+                                Returns an array representation of the selected date according to
+                                the conventions of the object's locale. The returned array is equivalent to
+                                PHP's <ulink url="http://php.net/getdate">getdate()</ulink> function and includes:
+                            </para>
+                            <para>
+                                <itemizedlist>
+                                    <listitem>
+                                        <para>
+                                            Number of day as '<emphasis>day</emphasis>'
+                                            (<classname>Zend_Date::DAY_SHORT</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Number of month as '<emphasis>month</emphasis>'
+                                            (<classname>Zend_Date::MONTH_SHORT</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Year as '<emphasis>year</emphasis>'
+                                            (<classname>Zend_Date::YEAR</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Hour as '<emphasis>hour</emphasis>'
+                                            (<classname>Zend_Date::HOUR_SHORT</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Minute as '<emphasis>minute</emphasis>'
+                                            (<classname>Zend_Date::MINUTE_SHORT</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Second as '<emphasis>second</emphasis>'
+                                            (<classname>Zend_Date::SECOND_SHORT</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Abbreviated timezone as '<emphasis>timezone</emphasis>'
+                                            (<classname>Zend_Date::TIMEZONE</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Unix timestamp as '<emphasis>timestamp</emphasis>'
+                                            (<classname>Zend_Date::TIMESTAMP</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Number of weekday as '<emphasis>weekday</emphasis>'
+                                            (<classname>Zend_Date::WEEKDAY_DIGIT</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Day of year as '<emphasis>dayofyear</emphasis>'
+                                            (<classname>Zend_Date::DAY_OF_YEAR</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Week as '<emphasis>week</emphasis>'
+                                            (<classname>Zend_Date::WEEK</classname>)
+                                        </para>
+                                    </listitem>
+                                    <listitem>
+                                        <para>
+                                            Delay of timezone to GMT as
+                                            '<emphasis>gmtsecs</emphasis>'
+                                            (<classname>Zend_Date::GMT_SECS</classname>)
+                                        </para>
+                                    </listitem>
+                                </itemizedlist>
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>toValue()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>toValue($part = null)</emphasis>
+                            </para>
+                            <para>
+                                Returns an integer representation of the selected date <code>$part</code> according to
+                                the conventions of the object's locale. Returns <code>false</code> when
+                                <code>$part</code> selects a non-numeric value, such as
+                                <classname>Zend_Date::MONTH_NAME_SHORT</classname>. <emphasis>NOTE:</emphasis> This
+                                method calls
+                                <link linkend="id.date.basic.operations"><code>get()</code>
+                                </link>
+                                and casts the result to a PHP integer, which will give unpredictable results, if
+                                <code>get()</code> returns a numeric string containing a number too large for a PHP
+                                integer on your system. Use <code>get()</code> instead.
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>
+                            <link linkend="id.date.basic.operations">get()</link>
+                        </entry>
+                        <entry>
+                            <para>
+                                <emphasis>get($part = null, $locale = null)</emphasis>
+                            </para>
+                            <para>
+                                This method returns the <code>$part</code> of object's date localized to
+                                <code>$locale</code> as a formatted string or integer. See
+                                <xref linkend="id.date.basic.operations" />
+                                for more information.
+                            </para>
+                        </entry>
+                    </row>
+                    <row>
+                        <entry>now()</entry>
+                        <entry>
+                            <para>
+                                <emphasis>now($locale = null)</emphasis>
+                            </para>
+                            <para>
+                                This convenience function is equivalent to <code>new Zend_Date()</code>. It returns the
+                                current date as a <classname>Zend_Date</classname> object, having <code>$locale</code>
+                            </para>
+                        </entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
+
+    </sect2>
+
+    <sect2 id="zend.date.others.fractions">
+
+        <title>Working with Fractions of Seconds</title>
+
+        <para>
+            Several methods support retrieving values related to a <classname>Zend_Date</classname> instance.
+        </para>
+
+        <table id="zend.date.others.fractions.table">
+            <title>Date Output Methods</title>
+            <tgroup cols="2">
+                <thead>
+                    <row>
+                        <entry>Method</entry>
+                        <entry>Explanation</entry>
+                    </row>
+                </thead>
+                <tbody>
+                    <row>
+                        <entry>
+                            <para>
+                                <emphasis>getFractionalPrecision()</emphasis>
+                            </para>
+                        </entry>
+                        <entry>Return the precision of the part seconds</entry>
+                    </row>
+                    <row>
+                        <entry>
+                            <para>
+                                <emphasis>setFractionalPrecision()</emphasis>
+                            </para>
+                        </entry>
+                        <entry>Set the precision of the part seconds</entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
+
+    </sect2>
+
+    <sect2 id="zend.date.other.sun">
+
+        <title>Sunrise / Sunset</title>
+
+        <para>
+            Three methods provide access to geographically localized information about the Sun, including the time of
+            sunrise and sunset.
+        </para>
+
+        <table id="zend.date.other.sun.table">
+            <title>Miscellaneous Methods</title>
+            <tgroup cols="2">
+                <thead>
+                    <row>
+                        <entry>Method</entry>
+                        <entry>Explanation</entry>
+                    </row>
+                </thead>
+                <tbody>
+                    <row>
+                        <entry>
+                            <para>
+                                <emphasis>getSunrise($location)</emphasis>
+                            </para>
+                        </entry>
+                        <entry>Return the date's time of sunrise</entry>
+                    </row>
+                    <row>
+                        <entry>
+                            <para>
+                                <emphasis>getSunset($location)</emphasis>
+                            </para>
+                        </entry>
+                        <entry>Return the date's time of sunset</entry>
+                    </row>
+                    <row>
+                        <entry>
+                            <para>
+                                <emphasis>getSunInfo($location)</emphasis>
+                            </para>
+                        </entry>
+                        <entry>Return an array with the date's sun dates</entry>
+                    </row>
+                </tbody>
+            </tgroup>
+        </table>
+
+    </sect2>
+
+</sect1>
+<!--
+vim:se ts=4 sw=4 et:
+-->