Spanish translation

Author: merongivian

LANGS.md

@@ -1,2 +1,3 @@
 * [English](en/)
-* [Japanese](ja/)
+* [Spanish](es/)
+* [Japanese](ja/)

es/README.md

@@ -0,0 +1,20 @@
+# Introducción
+
+Volt es un web framework donde tu código Ruby corre tanto en el servidor como en el cliente (por medio de [opal](https://github.com/opal/opal)). El DOM se actualiza al mismo tiempo que el usuario interactua con la página. El estado de la página puede ser guardado en el url. Si el usuario ingresa la url directamente, el HTML se carga primero en el servidor (para una carga mas rápida y una mejor indexación en motores de busqueda) para luego ser manejada en el cliente.
+
+En lugar de sincronizar los datos entre el cliente y el servidor por http, Volt usa una conección permanente. Cuando los datos son actualizados en un cliente específico estos cambios se reflejan tanto en la base como en otros clientes (sin ninguna configuración adicional).
+
+El HTML se escribe en un lenguaje de templating donde puedes ingresar código ruby entre ```{{``` y ```}}```. Volt usa programación reactiva para propagar automáticamente los actualizaciones al DOM (o cualquier parte del código que necesita saber cuando los datos han sido cambiados). Cuando una parte del DOM cambia, Volt actualiza solo los nodos que necesitan ser actualizados.
+
+Adicional a la documentación, puedes obtener mas ayuda en los siguientes videos:
+
+- [Volt Todos Example](https://www.youtube.com/watch?v=KbFtIt7-ge8)
+- [What Is Volt in 6 Minutes](https://www.youtube.com/watch?v=P27EPQ4ne7o)
+- [Pagination Example](https://www.youtube.com/watch?v=1uanfzMLP9g)
+- [Routes and Templates](https://www.youtube.com/watch?v=1yNMP3XR6jU)
+- [Isomorphic App Development - RubyConf 2014](https://www.youtube.com/watch?v=7i6AL7Walc4)
+
+O revisa las aplicaciones de demostración:
+ - https://github.com/voltrb/todomvc
+ - https://github.com/voltrb/blog5
+

es/SUMMARY.md

@@ -0,0 +1,76 @@
+# Resumen
+
+* [Introducción](README.md)
+* [Objetivos](introduction/README.md)
+* [Tutorial](tutorial/README.md)
+   * [Ejemplo de aplicación de tareas](tutorial/a_sample_todo_app.md)
+   * [Mas funcionalidad de aplicación de tareas](tutorial/todo_functionality.md)
+* [Docs](docs/README.md)
+   * [Vistas](docs/views.md)
+       * [Binding de Contenido](docs/content_binding.md)
+       * [Binding If](docs/if_binding.md)
+       * [Binding Each](docs/each_binding.md)
+       * [Bindings de Atributos](docs/attribute_bindings.md)
+       * [Bindings de Vistas](docs/view_bindings.md)
+       * [Binding Yield](docs/yield_binding.md)
+       * [Escape de Bindings](docs/escaping.md)
+       * [Bindings de Eventos](docs/event_bindings.md)
+   * [Modelos](docs/models.md)
+       * [Colecciones Proporcionadas](docs/provided_collections.md)
+       * [Colecciones Store](docs/store_collections.md)
+       * [Colecciones Anidadas](docs/sub_collections.md)
+       * [Conversión automática del modelo](docs/automatic_model_conversion.md)
+       * [Colecciones Flash, Local, y Cookies](docs/flash_collection.md)
+       * [Clases de Modelo](docs/model_classes.md)
+       * [Asociaciones](docs/associations.md)
+       * [Buffers](docs/buffers.md)
+       * [Validaciones](docs/validations.md)
+       * [Eventos ArrayModel](docs/arraymodel_events.md)
+       * [Permisos](docs/permissions.md)
+       * [Estados del Modelo](docs/model_states.md)
+   * [Controladores](docs/controllers.md)
+       * [Accessors Reactivos](docs/reactive_accessors.md)
+       * [url_for y url_with](docs/url_for_and_url_with.md)
+       * [Filtros Before/After](docs/beforeafter_actions.md)
+       * [Callbacks y Acciones](docs/callbacks_and_actions.md)
+       * [Obteniendo Nodos DOM de las vistas](docs/getting_view_dom_nodes.md)
+   * [Renderizado](docs/rendering.md)
+   * [Controladores HTTP](docs/http_controllers.md)
+       * [Middleware](docs/middleware.md)
+   * [Tasks](docs/tasks.md)
+   * [Componentes](docs/components.md)
+       * [Dependencias](docs/dependencies.md)
+       * [Assets](docs/assets.md)
+       * [Gemas de Componentes](docs/component_gems.md)
+       * [Componentes por Default](docs/provided_components.md)
+   * [Tags](docs/tags.md)
+       * [Argumentos/Atributos de Tags](docs/tag_attributes.md)
+   * [Rutas](docs/routes.md)
+       * [Archivo de Rutas](docs/routes_file.md)
+   * [Url](docs/url.md)
+   * [Usuarios](docs/users.md)
+   * [Channel](docs/channel.md)
+   * [Bus de Mensajes](docs/message_bus.md)
+   * [Testing](docs/testing.md)
+   * [Debugging](docs/debugging.md)
+   * [Helpers de Volt](docs/volt_helpers.md)
+   * [Comando Volt](docs/volt_command.md)
+   * [Lib](docs/lib.md)
+   * [Opciones de Environment](docs/environment_options.md)
+* [Deployment](deployment/README.md)
+   * [Heroku](deployment/heroku.md)
+   * [Docker](deployment/docker.md)
+   * [Cloud9](deployment/cloud9.md)
+* [Obtener Ayuda](getting_help/README.md)
+* [FAQ](getting_help/faq.md)
+   * [Qué corre en el servidor vs el cliente ?](getting_help/what_runs_on_the_client_vs_server.md)
+   * [Puedo usar jQuery? (u otras librerias para la manipulación del DOM?)](getting_help/can_i_use_jquery_or_other_dom_manipulating_js.md)
+   * [Puedo usar las gemas de opal?](getting_help/can_i_use_opal_gems.md)
+   * [Cuál es la diferencia entre Volt y Meteor?](getting_help/whats_the_difference_between_volt_and_meteor.md)
+   * [Al mantenerse una conección permanente podrían ocurrir problemas de rendimiento?](getting_help/is_keeping_a_persistent_connection_open_a_performance_problem.md)
+   * [Qué navegadores son soportados por Volt?](getting_help/what_browsers_does_volt_support.md)
+   * [Por que se usa undescore para los accessors en lugar de [:property]](getting_help/why_use_underscore_accessors_instead_of_[property].md)
+   * [Soporta Volt Haml, Slim, etc...](getting_help/does_volt_support_haml,_slim,_etc.md)
+* [Gemas de Componentes](contributing/component_gems.md)
+* [Contribuye](contributing/README.md)
+

es/book.json

@@ -0,0 +1,5 @@
+
+{
+    "title": "Volt Introduction and Docs",
+    "description": "Volt is a Ruby web framework where your ruby code runs on both the server and the client (via opal). The DOM automatically updates as the user interacts with the page. Page state can be stored in the URL. If the user hits a URL directly, the HTML will first be rendered on the server for faster load times and easier indexing by search engines.\n\nInstead of syncing data between the client and server via HTTP, Volt uses a persistent connection between the client and server. When data is updated on one client, it is updated in the database and any other listening clients (with almost no setup code needed).\n\nPages HTML is written in a handlebars-like template language. Volt uses data flow/reactive programming to automatically and intelligently propagate changes to the DOM (or any other code wanting to know when a value updates). When something in the DOM changes, Volt intelligently updates only the nodes that need to be changed."
+}

es/contributing/README.md

@@ -0,0 +1,5 @@
+# Como Contribuir
+
+Quieres contribuir? Genial! Tenemos la documentación completa de como contribuir
+aquí:
+https://github.com/voltrb/volt/blob/master/CONTRIBUTING.md

es/contributing/component_gems.md

@@ -0,0 +1,3 @@
+# Gemas de Componentes
+
+NOTA: Esta sección todavía está en proceso

es/deployment/README.md

@@ -0,0 +1,4 @@
+# Despliegue de aplicaciones volt
+
+Este capítulo trata varias opciones para el despliegue de aplicaciones Volt
+(proveedores cloud)

es/deployment/cloud9.md

@@ -0,0 +1,54 @@
+# Cloud9
+
+Para empezar en cloud9, crea una imagen de rails (esta imagen contiene lo que necesitamos). Una vez encendido, elimina el proyecto:
+
+```rm -rf *```
+
+Primero configuremos mongo (revisa la documentación completa para mongo aquí)
+
+Inicia una nueva terminal y digita lo siguiente:
+
+```
+mkdir data
+echo 'mongod --bind_ip=$IP --dbpath=data --nojournal --rest "$@"' > mongod
+chmod a+x mongod
+```
+
+Luego puedes correr mongod con el siguiente comando:
+
+```
+./mongod
+```
+
+Luego instalaremos Volt.
+
+```gem install volt```
+
+Y crearemos un nuevo proyecto:
+
+```volt new projectname```
+
+ingresamos al proyecto:
+
+```cd projectname```
+
+Y arrancamos el servidor (en Cloud9, debes pasar el puerto y la ip del ENV)
+
+```bundle exec volt server -p $PORT -b $IP```
+
+Cloud9 proveé un subdominio para cada aplicación, para visitar la aplicación has click en ```Preview``` y luego en ```Preview Running Application```
+
+En la versión gratuita de Cloud9, tu base mongo se apagará periódicamente (no de forma correcta).Puedes crear una base Mongo gratuita en www.mongolab.com.  Crea una cuenta gratuita en mongolab y luego añade lo siguiente en config/app.rb
+
+```
+config.db_driver = 'mongo'
+config.db_name = (config.app_name + '_' + Volt.env.to_s)
+if ENV['MONGOHQ_URL'].present?```
+  config.db_uri = ENV['MONGOHQ_URL'] # you will have to set this on Cloud9.
+else
+  config.db_host = 'localhost'
+  config.db_port = 27017
+end
+```
+
+NOTA: Si alguien puede crear una imagen customizada de Volt para cloud9, por favor hágamelo saber en el chat de gitter. Gracias!

es/deployment/docker.md

@@ -0,0 +1,21 @@
+## Contenedor Docker para Volt
+
+Crea un Dockerfile en tu aplicación de Volt con lo siguiente:
+
+```
+FROM otzy007/voltframework
+```
+
+Luego de esto puedes crear tu imagen de Docker
+
+```
+FROM otzy007/voltframework
+```
+
+Y correrlo:
+
+```
+docker run --name my-volt-app -p 3000:3000 -d my-volt-app
+```
+
+Ahora ya puedes ver tu aplicación en esta direccion: http://localhost:3000

es/deployment/heroku.md

@@ -0,0 +1,20 @@
+## Heroku
+
+Edita tu ```Gemfile``` y especifica tu versión de ruby, por ejemplo:
+
+```ruby
+source 'https://rubygems.org'
+
+ruby "2.1.3" # specify a Ruby version
+
+gem 'volt', ~> '0.9.0'
+```
+
+Añade un ```Procfile``` que use Thin
+
+    web: bundle exec thin start -p $PORT -e $RACK_ENV
+
+Configura tu conección a la base de datos en ```config/app.rb```, a continuación podemos ver un ejemplo para conectar con MongoHQ. Tienes que cambiarlo para el proveedor que usarás.
+[MongoLab](http://www.mongolab.com) es una alternativa gratuita.
+
+Puedes ver un ejemplo de aplicación deployada con heroku [aquí](https://murmuring-hollows-3078.herokuapp.com/about).

es/docs/README.md

@@ -0,0 +1,5 @@
+# Documentación
+
+Lo siguiente pretende documentar todo las características implementadas en Volt.
+Aunque el código fuente será siempre la principal fuente para obtener información
+al día, tratamos de mantener esta documentación lo mas actualizada posible.

es/docs/arraymodel_events.md

@@ -0,0 +1,17 @@
+## Eventos ArrayModel
+
+Los ArrayModels lanzan eventos cuando los datos son actualizados. Actualmente
+los modelos pueden generar dos eventos ```added``` y ```removed```. Por ejemplo:
+
+```ruby
+page._items.on('added') { puts 'item added' }
+page._items << 1
+# => item added
+
+page._items.on('removed') { puts 'item removed' }
+page._items.delete_at(0)
+# => item removed
+```
+
+Esto es usado internamente para los each bindings, pero puedes usarlo
+en tu propio código.

es/docs/assets.md

@@ -0,0 +1,39 @@
+# Assets
+
+## CSS y JavaScript
+
+En Volt, los archivos de assets como JavaScript y CSS (o sass) son incluidos automáticamente. Cualquier archivo que se agregue dentro de los paths assets/js o assets/cs son agregados a /assets/{js,css} (por medio de [Sprockets](https://github.com/sstephenson/sprockets)). Los tags de Link y script son agregados para cada archivo css y javascript respectivamente. Los archivos son agregados en orden léxico, por lo que puedes agregar un numero al principio del archivo si necesitas cambiar el orden con el que se va a cargar.
+
+Cualquier archivo JS/CSS de un componente añadido o de una gema componente también serán incluidos. [Bootstrap](http://getbootstrap.com/) es incluido gracias a la gema volt-bootstrap
+
+### Deshabilitando el auto-import de assets para agregarlos manualmente
+
+Si quieres agregar los archivos de assets manualmente, puedes deshabilitar el auto-import de CSS y JS por componente especificando ```disable_auto_import``` en la parte superior del archivo ```config/dependencies.rb```. Luego puedes incluir archivos CSS y JS para cada componente manualmente usando los helpers que se muestran a continuación.
+
+```disable_auto_import``` solo deshabilita la inclusión automática de JS y CSS. Archivos de tipografía, imágenes y otros assets no se verán afectados.
+
+Por ejemplo, si el archivo ```config/dependencies.rb``` de tu componente luce de la siguiente manera:
+
+```
+disable_auto_import
+css_file 'manifest.scss'
+# font awesome
+css_file '//maxcdn.bootstrapcdn.com/font-awesome/4.3.0/css/font-awesome.min.css'
+javascript_file 'my_js.min.js'
+```
+
+Solo el archivo 'manifest.scss', el link CDN para la tipografía y el archivo JS minificado seran incluídos en la página.
+
+##### javascript_file
+```javascript_file 'my_js.js'```
+Este helper buscará tu archivo en ```app/{component}/assets/js```.
+
+##### css_file
+```css_file 'my_scss.scss'```
+Este helper buscará tu archivo en ```app/{component}/assets/css```. Puedes usarlo con archivos SCSS o CSS . Usando esto puedes crear un archivo manifest para especificar el orden de carga de los archivos de estilo.
+
+## Imagenes, Tipografías y otros Assets
+
+Es recomendable que las imágenes y otros assets se encuentren ubicados en ```app/{component}/assets/images``` (o fonts, etc..), luego el url para las imágenes será: ```/assets/{component}/assets/images/...```. Las imágenes y otros assets no se verán afectados por ```disable_auto_import```.
+
+**Nota: asset building se encuentra todavía en construcción**

es/docs/associations.md

@@ -0,0 +1,46 @@
+# Asociaciones
+
+Volt proveé modelos anidados, los cuales se pueden acceder sin una declaración explícita. Aunque, por lo general tendrás que asociar otros modelos usando id's externas. Volt usa la convención de usar undescore ```_id``` para los nombres de los campos. Volt también proveé métodos como ```belongs_to``` , ```has_many``` y ```has_one``` para asociar modelos.
+
+```ruby
+class Person < Volt::Model
+  has_many :addresses
+end
+
+class Address < Volt::Model
+  belongs_to :person
+  has_one :street
+end
+
+class Street < Volt::Model
+end
+```
+
+## Has Many
+
+Puedes usar ```has_many``` para acceder a todas las instancias de otros modelos que tienen un campo ```_id``` apuntando al modelo actual. Por ejemplo si tenemos una instancia person:
+
+```ruby
+person.addresses
+# => #<Volt::ArrayModel [#<Address ..>, #<Address ..>, ...]>
+```
+
+Podemos llamar al método .addresses de person para encontrar todos los ```addresses``` con el id de person.
+
+Las asociaciones ```has_many``` retornan un cursor.
+
+## Has One
+
+Puedes llamar ```has_one``` en un modelo para crear una asociación con un único modelo. ```has_one``` toma un símbolo para el nombre del otro modelo. Si pasamos ```:street``` en un modelo ```Address```, Volt buscará un modelo ```Street``` que tiene el address_id del id del modelo ```Address```.
+
+## Belongs to
+
+Puedes usar ```belongs_to``` para enlazar un modelo padre. Por ejemplo, si tenemos una instancia de ```Address```:
+
+```ruby
+address.person.then do |person|
+  # => person is: #<Person ...>
+end
+```
+
+Las asociaciones ```belongs_to``` retornan una promesa que se resuelve con el modelo asociado.

es/docs/attribute_bindings.md

@@ -0,0 +1,54 @@
+# Bindings de Atributo
+
+Los bindings también pueden ser ingresados dentro de atributos
+
+```html
+<p class="{{ if is_cool? }}cool{{ end }}">Text</p>
+```
+
+## Bindings de atributos de dos vias
+
+Volt nos permite tener elementos que actuan como enlaces de "dos vías":
+
+```html
+<input type="text" value="{{ _name }}" />
+```
+
+Si la variable ```_name``` cambia, el valor del text-box cambiará automáticamente.  El enlace llama a ```_name``` en el controlador para obtener el valor de esa variable. Cuando un usuario escribe en el text box, su método setter sera invocado en el controlador. En este caso se llamará a ```_name=``` en el controlador y el nuevo valor sera guardado. Esto nos da el efecto de un enlace de dos vías, pero también tienes la capacidad de cambiar como los datos son actualizados ( definiendo otro setter, por ejemplo)
+
+## CheckBoxes
+
+En el siguiente ejemplo, si ```_name``` cambia, el campo se actualizará, y si el campo es actualizado por el usuario, ```_name``` tambien cambiará.
+
+```html
+<input type="checkbox" checked="{{ _checked }}" />
+```
+
+Si el valor ingresado es ```true```, el checkbox se marcara como checked.  El valor sera marcado o desmarcado si el valor es ```true``` o ```false``` respectivamente.
+
+## Radio Buttons
+
+Los radio buttons también estan enlazados a un estado, solo que en lugar de tener un valor booleano esto se obtienen del valor del campo seleccionado.
+
+```html
+<input type="radio" checked="{{ _radio }}" value="one" />
+<input type="radio" checked="{{ _radio }}" value="two" />
+```
+
+Cuando un valor se selecciona en el radio button, este cambio se verá reflejado a su vez en el campo enlazado, sin importar el valor anterior. Cuando el valor enlazado se cambia, cualquier campo en cualquier radio button que tenga el mismo valor que la variable será marcado.
+
+## Select Boxes
+
+Los select boxes se pueden enlazar a cualquier valor. (esto no lo puedes hacer con html normal, es una característica propia de Volt).
+
+```html
+<select value="{{ _rating }}">
+  <option value="1">*</option>
+  <option value="2">**</option>
+  <option value="3">***</option>
+  <option value="4">****</option>
+  <option value="5">*****</option>
+</select>
+```
+
+Cuando el valor seleccionado cambia, la variable ```_rating``` también será cambiada. Cuando ```_rating``` cambia el valor seleccionado es cambiado con el primer valor que concuerde. Si no se encuentra ningún valor en el select box este se marca como no seleccionado.