volt 0.7.18 → 0.7.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d287b57490af57c686f9f3b8a45dda2d953a8a19
-  data.tar.gz: 97a0201eda5adc10704ea7c689e27d596fff315b
+  metadata.gz: e52814d6fe0018d0ed9ff87c726b083c0d97c6d6
+  data.tar.gz: e45c97fe12819f7ab1abe17d9d0166379fa61a30
 SHA512:
-  metadata.gz: 3d0c17a7964f2f2b3a1d63cb299bed4f3160f40ac595425b04788fffe88d3b7a67fc83fd418d45b53c27b449c6ba55d6a0ba5dbd058368c0ec6b0c7255baf607
-  data.tar.gz: 6d6c453d1192cba6e277326f368d885973b5ee603d1303001a2b3b8cded4c6f82014a5006a7ed1d1b44c41ceac4dd582ec966fcf099e7548605ca91da938421c
+  metadata.gz: fccff09f4fe9c5ddeaf5d41a8e8fe4e284c9f1af137a11578ba08f6eafc336a6b13e27c4b3bf54665e6d6933c6c3e4f328db1b574e514a49764d188a223a64d7
+  data.tar.gz: ee4387876d87956bb39127f2fad009f42fc7c1078e50b409a1fa3f4c88a2e91c1ebf4b267b56acdaa711faceff03e6f8d402ceb3beeb56462247f63bbf8a1c6e

data/Readme.md

@@ -1,26 +1,27 @@
 [![Gem Version](https://badge.fury.io/rb/volt.png)](http://badge.fury.io/rb/volt)
 [![Code Climate](https://codeclimate.com/github/voltrb/volt.png)](https://codeclimate.com/github/voltrb/volt)
 [![Build Status](https://travis-ci.org/voltrb/volt.png?branch=master)](https://travis-ci.org/voltrb/volt)
+[![Volt Chat](https://badges.gitter.im/voltrb/volt.png)](https://gitter.im/voltrb/volt)
+[![Pledgie](https://pledgie.com/campaigns/26731.png?skin_name=chrome)](https://pledgie.com/campaigns/26731)
 
----
-> NOTE: VOLT IS STILL IN DEVELOPMENT, DON'T USE IT FOR ANYTHING SERIOUS YET
----
+=======
+** For the current status of volt, read: http://voltframework.com/blog
 
 # Volt
 
-Volt is a ruby web framework where your ruby code runs on both the server and the client (via [opal](https://github.com/opal/opal).)  The DOM automatically update 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.
+Volt is a Ruby web framework where your ruby code runs on both the server and the client (via [opal](https://github.com/opal/opal)).  The DOM automatically update 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.
 
-Instead of syncing data between the client and server via HTTP, volt uses a persistent connection between the client and server.  When data updated on one client, it is updated in the database and any other listening clients.  (With almost no setup code needed)
+Instead 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).
 
-Pages 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 anything 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.
+Pages 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 anything 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.
 
 See some demo videos here:
- - [https://www.youtube.com/watch?v=6ZIvs0oKnYs](https://www.youtube.com/watch?v=6ZIvs0oKnYs)
- - [https://www.youtube.com/watch?v=c478sMlhx1o](https://www.youtube.com/watch?v=c478sMlhx1o)
- - [https://www.youtube.com/watch?v=yZIQ-2irY-Q](https://www.youtube.com/watch?v=yZIQ-2irY-Q)
+ - [Volt Todos Example](https://www.youtube.com/watch?v=6ZIvs0oKnYs)
+ - [Build a Blog with Volt](https://www.youtube.com/watch?v=c478sMlhx1o)
+ - [Reactive Values in Volt](https://www.youtube.com/watch?v=yZIQ-2irY-Q)
 
 Check out demo apps:
- - https://github.com/voltrb/todos
+ - https://github.com/voltrb/todos3
  - https://github.com/voltrb/blog
  - https://github.com/voltrb/contactsdemo
 
@@ -30,10 +31,10 @@ Check out demo apps:
 Volt has the following goals:
 
 1. Developer happiness
-2. Write once on the client and the server
+2. Write once on the client and server
 3. Automatic data syncing between client and server
 4. Apps are built as nested components.  Components can be shared (via gems)
-5. Concurrent.  Volt provides tools to simplify concurrency.  Component rendering is done in parallel on the server.
+5. Concurrent.  Volt provides tools to simplify concurrency.  Component rendering is done in parallel on the server
 6. Intelligent asset management
 7. Secure (shouldn't need to be said, but it does)
 8. Be fast/light
@@ -44,18 +45,16 @@ Volt has the following goals:
 
 Many of the core Volt features are implemented.  We still have a bit to go before 1.0, most of it involving models.
 
-1. Database storing models
-2. Model validations (client and server side)
-3. Reactive model queries
-4. Reactive Enumerators with Blocks (.map .count, etc...)
-5. Full managed render loop (for fast rendering)
-6. Fix N+1 issue with some reactive values (I know how to fix, just haven't gotten around to doing it)
+1. Reactive model queries
+2. Reactive Enumerators with Blocks (.map .count, etc…)
+3. Full managed render loop (for fast rendering)
+4. Fix N+1 issue with some reactive values (I know how to fix it, just haven't gotten around to doing it)
 
 # VOLT guide
 
-This guide will take you through creating a basic web application in Volt.  This tutorial assumes a basic knowledge of ruby and web development.
+This guide will take you through creating a basic web application in Volt.  This tutorial assumes a basic knowledge of Ruby and web development.
 
-To get started, install volt:
+To get started, install Volt:
 
     gem install volt
 
@@ -63,11 +62,11 @@ Then create a new project:
 
     volt new project_name
 
-This will setup a basic project.  Now lets run the server.
+This will setup a basic project.  Now let's run the server:
 
     volt server
 
-You can access the volt console with:
+You can access the Volt console with:
 
     volt console
 
@@ -90,15 +89,16 @@ You can access the volt console with:
   3. [Model Events](#model-events)
   4. [Automatic Model Conversion](#automatic-model-conversion)
 5. [Controllers](#controllers)
-6. [Components](#components)
+6. [Tasks](#tasks)
+7. [Components](#components)
   1. [Dependencies](#dependencies)
   2. [Assets](#assets)
   3. [Component Generator](#component-generator)
   4. [Provided Components](#provided-components)
     1. [Notices](#notices)
     2. [Flash](#flash)
-7. [Controls](#controls)
-8. [Routes](#routes)
+8. [Controls](#controls)
+9. [Routes](#routes)
   1. [Routes file](#routes-file)
 
 
@@ -106,10 +106,10 @@ You can access the volt console with:
 
 Volt is still a work in progress, but early feedback is appreciated.  Use the following to communicate with the developers, someone will get back to you very quickly:
 
-- **If you need help**: post on [stackoverflow.com](http://www.stackoverflow.com), be sure to tag your question with voltrb
+- **If you need help**: post on [stackoverflow.com](http://www.stackoverflow.com). Be sure to tag your question with `voltrb`.
 - **If you found a bug**: post on [github issues](https://github.com/voltrb/volt/issues)
 - **If you have an idea or need a feature**: post on [github issues](https://github.com/voltrb/volt/issues)
-- **If you want to discuss volt**: use #voltrb on freenode.
+- **If you want to discuss Volt**: use #voltrb on freenode.
 
 
 # Rendering
@@ -123,7 +123,7 @@ For example when a user clicks to add a new todo item to a todo list, we might c
 
 The idea of "reactive programming" has been used to simplify maintaining the DOM.  The idea is instead of having event handlers that manage a model (or JavaScript object) and manage the DOM, we have event handlers that manage reactive data models.  We describe our DOM layer in a declarative way so that it automatically knows how to render our data models.
 
-## Reactive Value's
+## Reactive Values
 
 To build bindings, Volt provides the ReactiveValue class.  This wraps any object in a reactive interface.  To create a ReactiveValue, simply pass the object you want to wrap as the first argument to new.
 
@@ -132,9 +132,9 @@ To build bindings, Volt provides the ReactiveValue class.  This wraps any object
     # => @"my object"
 ```
 
-When .inspect is called on a ReactiveValue (like in the console), an @ is placed in front of the value's inspect string, so you know its reactive.
+When `#inspect` is called on a ReactiveValue (like in the console), an '@' is placed in front of the value's inspect string, so you know it's reactive.
 
-When you call a method on a ReactiveValue, you get back a new reactive value that depends on the previous one.  It remembers how it was created and you can call .cur on it any time to get its current value, which will be computed based off of the first reactive value.  (Keep in mind below that + is a method call, the same as a.+(b) in ruby.)
+When you call a method on a ReactiveValue, you get back a new reactive value that depends on the previous one.  It remembers how it was created and you can call `#cur` on it any time to get its current value, which will be computed based off of the first reactive value.  (Keep in mind below that + is a method call, the same as `a.+(b)` in ruby.)
 
 ```ruby
     a = ReactiveValue.new(1)
@@ -156,9 +156,9 @@ When you call a method on a ReactiveValue, you get back a new reactive value tha
     # => 7
 ```
 
-This provides the backbone for reactive programming.  We setup computation/flow graphs instead of doing an actual calculation.  Calling .cur (or .inspect, .to_s, etc..) runs the computation and returns the current value at that time, based on all of its dependencies.
+This provides the backbone for reactive programming.  We setup computation/flow graphs instead of doing an actual calculation.  Calling `#cur` (or `#inspect`, `#to_s`, etc..) runs the computation and returns the current value at that time, based on all of its dependencies.
 
-ReactiveValue's also let you setup listeners and trigger events:
+ReactiveValues also let you setup listeners and trigger events:
 
 ```ruby
     a = ReactiveValue.new(0)
@@ -167,7 +167,7 @@ ReactiveValue's also let you setup listeners and trigger events:
     # => A Changed
 ```
 
-These events propagate to any reactive value's created off of a reactive value.
+These events propagate to any reactive values created off of a reactive value:
 
 ```ruby
     a = ReactiveValue.new(1)
@@ -180,7 +180,7 @@ These events propagate to any reactive value's created off of a reactive value.
 
 This event flow lets us know when an object has changed, so we can update everything that depended on that object.
 
-Lastly, we can also pass in other reactive value's as arguments to methods on a reactive value.  The dependencies will be tracked for both and events will propagate down from both.  (Also, note that doing `.cur =` to update the current value triggers a "changed" event.)
+Lastly, we can also pass in other reactive values as arguments to methods on a reactive value.  The dependencies will be tracked for both and events will propagate down from both.  (Also, note that calling `#cur=` to update the current value triggers a "changed" event.)
 
 ```ruby
     a = ReactiveValue.new(1)
@@ -200,27 +200,27 @@ Lastly, we can also pass in other reactive value's as arguments to methods on a
     # => C changed
 ```
 
-### ReactiveValue Gotcha's
+### ReactiveValue Gotchas
 
-There are a few simple things to keep in mind with ReactiveValue's.  In order to make them mostly compatible with other ruby objects, a two methods do not return another ReactiveValue.
+There are a few simple things to keep in mind with ReactiveValues.  In order to make them mostly compatible with other Ruby objects, two methods do not return another ReactiveValue.
 
     to_s and inspect
 
-If you want these to be used reactively, see the section on [with](#with)
+If you want these to be used reactively, see the section on [with](#with).
 
-Also, due to a small limitation in ruby, ReactiveValue's always are truthy.  See the [truthy checks](#truthy-checks-true-false-or-and-and) section on how to check for truth.
+Also, due to a small limitation in ruby, ReactiveValues always are truthy.  See the [truthy checks](#truthy-checks-true-false-or-and-and) section on how to check for truth.
 
-When passing something that may contain reactive values to a JS function, you can call ```.deep_cur``` on any object to get back a copy that will have all reactive value's turned into their current value.
+When passing something that may contain reactive values to a JS function, you can call ```#deep_cur``` on any object to get back a copy that will have all reactive values turned into their current value.
 
 ### Current Status
 
-NOTE: currently ReactiveValue's are not complete.  At the moment, they do not handle methods that are passed blocks (or procs, lambda's).  This is planned, but not complete.  At the moment you can use [with](#with) to accomplish similar things.
+NOTE: currently ReactiveValues are not complete.  At the moment, they do not handle methods that are passed blocks (or procs, lambdas).  This is planned, but not complete.  At the moment you can use [with](#with) to accomplish similar things.
 
 ### Truthy Checks: .true?, .false?, .or, and .and
 
 Because a method on a reactive value always returns another reactive value, and because only nil and false are false in ruby, we need a way to check if a ReactiveValue is truthy in our code.  The easiest way to do this is by calling .true? on it.  It will return a non-wrapped boolean.  .nil? and .false? do as you would expect.
 
-One common place we use a truthy check is in setting up default values with || (logical or)  Volt provides a convience method that does the same thing .or, but works with ReactiveValue's.
+One common place we use a truthy check is in setting up default values with || (logical or)  Volt provides a convenient method that does the same thing `#or`, but works with ReactiveValues.
 
 Instead of
 
@@ -234,14 +234,14 @@ Simply use:
     a.or(b)
 ```
 
-.and works the same way as &&.  #and and #or let you maintain the reactivity all of the way through.
+`#and` works the same way as &&.  #and and #or let you maintain the reactivity all of the way through.
 
 
 ### With
 
-Normally when you want to have a value that depends on another value, but transforms it somehow, you simply call your transform method on the ReactiveValue.  However sometimes the transform is not directly on the ReactiveValue's object.
+Normally when you want to have a value that depends on another value, but transforms it somehow, you simply call your transform method on the ReactiveValue.  However sometimes the transform is not directly on the ReactiveValues object.
 
-You can call .with on any ReactiveValue.  .with will return a new ReactiveValue that depends on the current ReactiveValue.  .with takes a block, the first argument to the block will be the cur value of the ReactiveValue you called with on.  Any additional arguments to with will be passed in after the first one.  If you pass another ReactiveValue as an argument to .with, the returned ReactiveValue will depend on the argument ReactiveValue as well, and the block will receive the arguments cur value.
+You can call `#with` on any ReactiveValue.  `#with` will return a new ReactiveValue that depends on the current ReactiveValue.  `#with` takes a block, the first argument to the block will be the cur value of the ReactiveValue you called `#with` on.  Any additional arguments to `#with` will be passed in after the first one.  If you pass another ReactiveValue as an argument to `#with`, the returned ReactiveValue will depend on the argument ReactiveValue as well, and the block will receive the arguments cur value.
 
 ```ruby
     a = ReactiveValue.new(5)
@@ -252,7 +252,7 @@ You can call .with on any ReactiveValue.  .with will return a new ReactiveValue
 
 # Views
 
-Views in Volt are use a templating language similar to handlebars.  They can be broken up into sections, a section header looks like the following:
+Views in Volt use a templating language similar to handlebars. They can be broken up into sections. A section header looks like the following:
 
 ```html
 <:Body>
@@ -260,11 +260,11 @@ Views in Volt are use a templating language similar to handlebars.  They can be
 
 Section headers should start with a capital letter so as not to be confused with [controls](#controls).  Section headers do not use closing tags.  If section headers are not provided, the Body section is assumed.
 
-Section's help you split up different parts of the same content (title and body usually), but within the same file.
+Sections help you split up different parts of the same content (title and body usually), but within the same file.
 
 ## Bindings
 
-One you understand the basics of ReactiveValue's, we can discuss bindings.  In Volt, you code your views in a handlebar's like template language.  Volt provides several bindings, which handle rendering of something for you.  Content bindings are anything inbetween { and }
+Once you understand the basics of ReactiveValues, we can discuss bindings. In Volt, you code your views in a handlebars like template language.  Volt provides several bindings, which handle rendering of something for you. Content bindings are anything inbetween { and }.
 
 ### Content binding
 
@@ -274,7 +274,7 @@ The most basic binding is a content binding:
     <p>{some_method}<p>
 ```
 
-The content binding runs the ruby code between { and }, then renders the return value.  If the returned value is a ReactiveValue, it will update the value updated whenever a 'changed' event is triggered on the reactive value.
+The content binding runs the Ruby code between { and }, then renders the return value.  If the returned value is a ReactiveValue, it will update the value updated whenever a 'changed' event is triggered on the reactive value.
 
 ### If binding
 
@@ -288,7 +288,7 @@ An if binding lets you provide basic flow control.
 
 Blocks are closed with a {/}
 
-When the #if binding is rendered, it will run the ruby code after #if.  If the code is true it will render the code below.  Again, if the returned value is reactive, it will update as that value changes.
+When the if binding is rendered, it will run the ruby code after #if.  If the code is true it will render the code below.  Again, if the returned value is reactive, it will update as that value changes.
 
 If bindings can also have #elsif and #else blocks.
 
@@ -312,7 +312,7 @@ For iteration over objects, the each binding is provided.
     {/}
 ```
 
-Above, if _items was an array, the block would be rendered for each item, setting 'item' to the value of the array element.
+Above, if _items were an array, the block would be rendered for each item, setting 'item' to the value of the array element.
 
 You can also access the position of the item in the array with the #index method.
 
@@ -330,7 +330,7 @@ For the array: ['one', 'two', 'three'] this would print:
 
 You can do {index + 1} to correct the zero offset.
 
-When items are removed or added to the array, the #each binding automatically and intelligently add or removes the items from/to the DOM.
+When items are removed or added to the array, the #each binding automatically and intelligently adds or removes the items from/to the DOM.
 
 ## Attribute Bindings
 
@@ -340,19 +340,19 @@ Bindings can also be placed inside of attributes.
     <p class="{#if _is_cool?}cool{/}">Text</p>
 ```
 
-There are some special features provided to make for elements work as "two way bindings"
+There are some special features provided to make elements work as "two way bindings":
 
 ```html
     <input type="text" value="{_name}" />
 ```
 
-In the example above, if _name changes, the field will update and if the field is updated, _name will be changed.
+In the example above, if _name changes, the field will update, and if the field is updated, _name will be changed:
 
 ```html
     <input type="checkbox" checked="{_checked}" />
 ```
 
-If the value of a checked attribute is true, the checkbox will be shown checked.  If it is checked/unchecked, the value will be updated to true or false.
+If the value of a checked attribute is true, the checkbox will be shown checked. If it's checked or unchecked, the value will be updated to true or false.
 
 -- TODO: select boxes
 
@@ -360,7 +360,7 @@ If you have a controller at app/home/controller/index_controller.rb, and a view
 
 ## Escaping
 
-When you need to use { and } outside of bindings.  Anything in a triple mustache will be escaped and not processed as a binding:
+When you need to use { and } outside of bindings, anything in a triple mustache will be escaped and not processed as a binding:
 
 ```html
     {{{ bindings look like: {this}  }}}
@@ -370,7 +370,7 @@ When you need to use { and } outside of bindings.  Anything in a triple mustache
 
 Volt's concept of a model is slightly different from many frameworks where a model is the name for the ORM to the database.  In Volt a model is a class where you can store data easily.  Models can be created with a "Persistor", which is responsible for storing the data in the model.  Models created without a persistor, simply store the data in the classes instance.  Lets first see how to use a model.
 
-Volt comes with many built-in models, one is called 'page'.  If you call #page on a controller, you will get access to the model.  Models provided by Volt are automatically wrapped in a ReactiveValue so update events can be tracked.
+Volt comes with many built-in models; one is called `page`.  If you call `#page` on a controller, you will get access to the model.  Models provided by Volt are automatically wrapped in a ReactiveValue so update events can be tracked.
 
 ```ruby
     page._name = 'Ryan'
@@ -378,7 +378,7 @@ Volt comes with many built-in models, one is called 'page'.  If you call #page o
     # => @'Ryan'
 ```
 
-Models act like a hash that you can access with getters and setters that start with an _   If an underscore method is called that hasn't yet been assigned, you will get back a "nil model".  Prefixing with an underscore makes sure we don't accidentally try to call a method that doesn't exist and get back nil model instead of raising an exception.  There is no need to define which fields a model has, they act similar to a hash, but with a different access and assign syntax.
+Models act like a hash that you can access with getters and setters that start with an _ .  If an underscore method is called that hasn't yet been assigned, you will get back a "nil model".  Prefixing with an underscore makes sure we don't accidentally try to call a method that doesn't exist and get back nil model instead of raising an exception.  There is no need to define which fields a model has. Fields behave similarly to a hash, but with a different access and assignment syntax.
 
 Models also let you nest data without creating the intermediate models:
 
@@ -393,7 +393,7 @@ Models also let you nest data without creating the intermediate models:
 
 Nested data is automatically setup when assigned.  In this case, page._settings is a model that is part of the page model.
 
-You can also append to a model if its not defined yet.  In Volt models, plural properties are assumed to contain arrays (or more specifically ArrayModels)
+You can also append to a model if it's not defined yet.  In Volt models, plural properties are assumed to contain arrays (or more specifically, ArrayModels).
 
 ```ruby
     page._items << 'item 1'
@@ -408,7 +408,7 @@ ArrayModels can be appended to and accessed just like regular arrays.
 
 ## Provided Collections
 
-Above I mentioned that Volt comes with many default collection models accessible from a controller.  Each stores in a different location.
+Above, I mentioned that Volt comes with many default collection models accessible from a controller.  Each stores in a different location.
 
 | Name      | Storage Location                                                          |
 |-----------|---------------------------------------------------------------------------|
@@ -423,11 +423,11 @@ Above I mentioned that Volt comes with many default collection models accessible
 
 ## Reactive Models
 
-Because all models provided by Volt are wrapped in a ReactiveValue, you can register listeners on them and be updated when values change.  You can also call methods on their values and get updates when the source's change.  Bindings also setup listeners.  Models should be the main place you store all data in Volt.  While you can use ReactiveValue's manually, most of the time you will want to just use something like the controller model.
+Because all models provided by Volt are wrapped in a ReactiveValue, you can register listeners on them and be updated when values change.  You can also call methods on their values and get updates when the sources change.  Bindings also setup listeners.  Models should be the main place you store all data in Volt.  While you can use ReactiveValues manually, most of the time you will want to just use something like the controller model.
 
 ## Model Events
 
-Models trigger events when their data is updated.  Currently models emit three events: changed, added, and removed.  For example:
+Models trigger events when their data is updated.  Currently, models emit three events: changed, added, and removed.  For example:
 
 ```ruby
     model = Model.new
@@ -467,9 +467,9 @@ For convenience, when placing a hash inside of another model, it is automaticall
     # => Model
 ```
 
-Models are accessed differently from hashes.  Instead of using model[:symbol] to access, you call a method model.method_name.  This provides a dynamic unified store where setters and getters can be added without changing any access code.
+Models are accessed differently from hashes.  Instead of using `model[:symbol]` to access, you call a method `model.method_name`.  This provides a dynamic unified store where setters and getters can be added without changing any access code.
 
-You can get a ruby hash back out by calling .to_h on a Model.
+You can get a Ruby hash back out by calling `#to_h` on a Model.
 
 ### Array -> ArrayModel
 
@@ -487,7 +487,7 @@ Arrays inside of models are automatically converted to an instance of ArrayModel
 ```
 
 
-To convert a Model or an ArrayModel back to a normal hash, call .to_h or .to_a respectively.  To convert them to a JavaScript Object (for passing to some JavaScript code), call .to_n (to native).
+To convert a Model or an ArrayModel back to a normal hash, call .to_h or .to_a respectively.  To convert them to a JavaScript Object (for passing to some JavaScript code), call `#to_n` (to native).
 
 ```ruby
     user = Model.new
@@ -520,7 +520,7 @@ A controller can be any class in Volt, however it is common to have that class i
     end
 ```
 
-2. Calling self.method = in a method:
+2. Calling `self.model=` in a method:
 
 ```ruby
     class TodosController < ModelController
@@ -530,15 +530,15 @@ A controller can be any class in Volt, however it is common to have that class i
     end
 ```
 
-In methods, the #model method returns the current model.
+In methods, the `#model` method returns the current model.
 
 See the [provided collections](#provided-collections) section for a list of the available collection models.
 
 You can also provide your own object to model.
 
-In the example above any methods not defined on the TodosController will fall through to the provided model.  All views in views/{controller_name} will have this controller as the target for any ruby run in their bindings.  This means that calls on self (implicit or with self.) will have the model as their target (after calling through the controller).  This lets you add methods to the controller to control how the model is handled, or provide extra methods to the views.
+In the example above, any methods not defined on the TodosController will fall through to the provided model.  All views in views/{controller_name} will have this controller as the target for any Ruby run in their bindings.  This means that calls on self (implicit or with self.) will have the model as their target (after calling through the controller).  This lets you add methods to the controller to control how the model is handled, or provide extra methods to the views.
 
-Volt is more similar to an MVVM architecture than an MVC architecture.  Instead of the controllers passing data off to the views, the controllers are the context for the views.  When using a ModelController, the controller automatically forwards all methods it does not handle to the model.  This is convienant since you can set a model in the controller and then access its properties directly with methods in bindings.  This lets you do something like ```{_name}``` instead of something like ```{@model._name}```
+Volt is more similar to an MVVM architecture than an MVC architecture.  Instead of the controllers passing data off to the views, the controllers are the context for the views.  When using a ModelController, the controller automatically forwards all methods it does not handle to the model.  This is convenient since you can set a model in the controller and then access its properties directly with methods in bindings.  This lets you do something like ```{_name}``` instead of something like ```{@model._name}```
 
 Controllers in the app/home component do not need to be namespaced, all other components should namespace controllers like so:
 
@@ -554,7 +554,7 @@ Here "auth" would be the component name.
 
 ## Reactive Accessors
 
-The default ModelController proxies any missing methods to its model.  Since models are wrapped in ReactiveValue's, they return ReactiveValue's by default.  Sometimes you need to store additional data reactively in the controller outside of the model.  (Though often you may want to condier doing another control/controller)  In this case, you can add a ```reactive_accessor```.  These behave just like ```attr_accessor``` except the values assigned and returned are wrapped in a ReactiveValue.  Updates update the existing ReactiveValue.
+The default ModelController proxies any missing methods to its model.  Since models are wrapped in ReactiveValues, they return ReactiveValues by default.  Sometimes you need to store additional data reactively in the controller outside of the model.  (Though often you may want to condier doing another control/controller).  In this case, you can add a ```reactive_accessor```.  These behave just like ```attr_accessor``` except the values assigned and returned are wrapped in a ReactiveValue.  Updates update the existing ReactiveValue.
 
 ```ruby
   class Contacts < ModelController
@@ -564,6 +564,44 @@ The default ModelController proxies any missing methods to its model.  Since mod
 
 Now from the view we can bind to _query while also changing in and out the model.  You can also use ```reactive_reader``` and ```reactive_writer```
 
+# Tasks
+
+Sometimes you need to explicitly execute some code on the server. Volt solves this problem through *tasks*. You can define your own tasks by dropping a class into your component's ```tasks``` folder.
+
+```ruby
+    # app/main/tasks/logging_tasks.rb
+
+    class LoggingTasks
+        def initialize(channel=nil, dispatcher=nil)
+            @channel = channel
+            @dispatcher = dispatcher
+        end
+
+        def log(message)
+            puts message
+        end
+    end
+```
+
+To invoke a task from a controller use ```tasks.call```.
+
+```ruby
+    class Contacts < ModelController
+        def hello
+            tasks.call('LoggingTasks', 'log', 'Hello World!')
+        end
+    end
+```
+
+You can also pass a block to ```tasks.call``` that will receive the return value of your task as soon as it's done.
+
+```ruby
+    tasks.call('MathTasks', 'add', 23, 5) do |result|
+        # result should be 28
+        alert result
+    end
+```
+
 # Components
 
 Apps are made up of Components.  Each folder under app/ is a component.  When you visit a route, it loads all of the files in the component on the front end, so new pages within the component can be rendered without a new http request.  If a URL is visited that routes to a different component, the request will be loaded as a normal page load and all of that components files will be loaded.  You can think of components as the "reload boundary" between sections of your app.
@@ -593,7 +631,7 @@ Note above though that jquery and bootstrap are currently included by default.
 
 **Note, asset management is still early, and likely will change quite a bit**
 
-In volt, assets such as JavaScript and CSS (or sass) are automatically included on the page for you.  Anything placed inside of a components asset/js or assets/css folder is served at /assets/{js,css} (via [Sprockets](https://github.com/sstephenson/sprockets))  Link and script tags are automatically added for each css and js file in assets/css and assets/js respectively.  Files are included in their lexical order, so you can add numbers in front if you need to change the load order.
+In Volt, assets such as JavaScript and CSS (or sass) are automatically included on the page for you.  Anything placed inside of a components asset/js or assets/css folder is served at /assets/{js,css} (via [Sprockets](https://github.com/sstephenson/sprockets)).  Link and script tags are automatically added for each css and js file in assets/css and assets/js respectively.  Files are included in their lexical order, so you can add numbers in front if you need to change the load order.
 
 Any JS/CSS from an included component or component gem will be included as well.  By default [bootstrap](http://getbootstrap.com/) is provided by the volt-bootstrap gem.
 
@@ -617,7 +655,7 @@ Remove the path: option in the gemfile if you wish to use the rubygems version.
 
 ## Provided Components
 
-Volt provides a few components to make web developers lives easier.
+Volt provides a few components to make web developers' lives easier.
 
 ### Notices
 
@@ -641,7 +679,7 @@ These messages will show for 5 seconds, then disappear (both from the screen and
 
 # Controls
 
-Everyone wishes that we could predict the scope and required features for each part of our application, but in the real world, things we don't expect to grow large often do and things we think will be large don't end up that way.  Controls let you quickly setup reusable code/views.  The location of the control's code can be moved as it grows without changing the way controls are invoked.
+Everyone wishes that we could predict the scope and required features for each part of our application, but in the real world, things we don't expect to grow large often do and things we think will be large don't end up that way.  Controls let you quickly setup reusable code/views.  The location of the controls code can be moved as it grows without changing the way controls are invoked.
 
 To render a control, simply use a tag like so:
 
@@ -675,7 +713,7 @@ Each part is explained below:
 Views are composed of sections.  Sections start with a ```<:SectionName>``` and are not closed.  Volt will look first for a section in the same view.
 
 2. views
-Next Volt will look for a view file that with the control name.  If found, it will render the body section of that view.
+Next Volt will look for a view file with the control name.  If found, it will render the body section of that view.
 
 3. view folder
 Failing above, Volt will look for a view folder with the control name, and an index.html file within that folder.  It will render the :body section of that view.  If a controller exists for the view folder, it will make a new instance of that controller and render in that instance.
@@ -701,7 +739,7 @@ The above would search the following:
 | :body     | index.html   | comments       | blog        |
 | :body     | index.html   | comments       | gems/blog   |
 
-Once the view file for the control or template is found, it will look for a matching controller.  If the control is specified as a local template, an empty ModelController will be used.  If a controller is found and loaded, a corrosponding "action" method will be called on it if its exists.  Action methods default to "index" unless the component or template path has two parts, in which case the last part is the action.
+Once the view file for the control or template is found, it will look for a matching controller.  If the control is specified as a local template, an empty ModelController will be used.  If a controller is found and loaded, a corresponding "action" method will be called on it if its exists.  Action methods default to "index" unless the component or template path has two parts, in which case the last part is the action.
 
 # Control Arguments/Attributes
 
@@ -739,9 +777,9 @@ Routes are specified on a per-component basis in the config/routes.rb file.  Rou
 
 Routes take two arguments, a path, and a params hash.  When a new URL is loaded and the path is matched on a route, the params will be set to the params provided for that route.
 
-When the params are changed, the URL will be set to the path for the route that's params hash matches.
+When the params are changed, the URL will be set to the path for the route whose params hash matches.
 
-Route path's can also contain variables similar to bindings.
+Route paths can also contain variables similar to bindings:
 
 ```ruby
     get "/todos/{_index}", _view: 'todos'
@@ -749,22 +787,22 @@ Route path's can also contain variables similar to bindings.
 
 In the case above, if any URL matches /todos/*, (where * is anything but a slash), it will be the active route. ```params._view``` would be set to 'todos', and ```params._index``` would be set to the value in the path.
 
-If ```params._view``` is 'todos' and ```params._index``` is not nil, the route would be matched.
+If ```params._view``` were 'todos' and ```params._index``` were not nil, the route would be matched.
 
 Routes are matched top to bottom in a routes file.
 
 ## Debugging
 
-An in browser irb is in the works.  We also have source maps support, but they are currently disabled due by default.  To enable them run:
+An in browser irb is in the works.  We also have source maps support, but they are currently disabled by default.  To enable them run:
 
     MAPS=true volt s
 
-They are disabled by default because they slow down page rendering because so many files are rendered.  We're working with the opal and sprockets teams to make it so everything is still served in one big source maps file (which would show the files as they originated on disk)
+This feature is disabled by default because (due to the volume of pages rendered) it slows down page rendering. We're working with the opal and sprockets teams to make it so everything is still served in one big source maps file (which would show the files as they originated on disk)
 
 
 ## Channel
 
-Controllers provide a .channel method, that you can use to get the status of the connection to the backend.  Channel is provided in a ReactiveValue, and when the status changes, the changed events are triggered.  It provides the following:
+Controllers provide a `#channel` method, that you can use to get the status of the connection to the backend.  Channel is provided in a ReactiveValue, and when the status changes, the changed events are triggered.  It provides the following:
 
 | method      | description                                               |
 |-------------|-----------------------------------------------------------|
@@ -788,7 +826,7 @@ Volt provides a data store collection on the front-end and the back-end.  In sto
 store._things
 ```
 
-**Work in process**
+**Work in progress**
 
 | state       | events bound | description                                                  |
 |-------------|--------------|--------------------------------------------------------------|
@@ -799,4 +837,4 @@ store._things
 
 # Contributing
 
-You want to contribute?  Great!  Thanks for being awesome!  At the moment, we have a big internal todo list, hop on #voltrb on freenode (irc) so we don't duplicate work.  Pull requests are always welcome, but asking about helping on IRC should save some duplication.
+You want to contribute?  Great!  Thanks for being awesome!  At the moment, we have a big internal todo list, hop on https://gitter.im/voltrb/volt so we don't duplicate work.  Pull requests are always welcome, but asking about helping on gitter should save some duplication.

data/VERSION

@@ -1 +1 @@
-0.7.18
+0.7.19

data/lib/volt/cli.rb

@@ -11,7 +11,7 @@ class CLI < Thor
     directory("project", name, {version: version, name: name})
 
     say "Bundling Gems...."
-    `cd #{name} ; bundle -j 4`
+    `cd #{name} && bundle`
   end
 
   desc "console", "run the console on the project in the current directory"

data/lib/volt/controllers/model_controller.rb

@@ -41,8 +41,6 @@ class ModelController
   end
 
   def initialize(*args)
-
-
     # Set the instance variable to match any passed in arguments
     if args.size > 0
       args[0].each_pair do |key, value|

data/lib/volt/models/persistors/model_store.rb

@@ -65,11 +65,16 @@ module Persistors
           @model.attributes[:"#{path[-4].singularize}_id"] = source._id
         end
 
-        @tasks.call('StoreTasks', 'save', collection, self_attributes) do |errors|
-          if errors.size == 0
-            promise.resolve
-          else
-            promise.reject(errors)
+        if !collection
+          puts "Attempting to save model directly on store."
+          raise "Attempting to save model directly on store."
+        else
+          @tasks.call('StoreTasks', 'save', collection, self_attributes) do |errors|
+            if errors.size == 0
+              promise.resolve
+            else
+              promise.reject(errors)
+            end
           end
         end
       end

data/lib/volt/models/validations.rb

@@ -73,7 +73,7 @@ module Validations
           if klass
             validate_with(merge, klass, field_name, args)
           else
-            raise "validtion type #{validation} is not specified."
+            raise "validation type #{validation} is not specified."
           end
         end
       end
@@ -95,4 +95,4 @@ module Validations
         puts "Unable to find #{validation} validator"
       end
     end
-end
+end

data/lib/volt/page/tasks.rb

@@ -46,7 +46,7 @@ class Tasks
     if callback
       if error
         # TODO: full error handling
-        puts "Error2: #{error.inspect}"
+        puts "Task Response: #{error.inspect}"
       else
         callback.call(result)
       end

data/lib/volt/reactive/reactive_value.rb

@@ -136,10 +136,6 @@ class ReactiveValue < BasicObject
       end
     end
   end
-  #
-  # def respond_to?(name, include_private=false)
-  #   [:event_added, :event_removed].include?(name) || super
-  # end
 
   def respond_to_missing?(name, include_private=false)
     cur.respond_to?(name)
@@ -428,5 +424,4 @@ class ReactiveManager
   def setter!(setter=nil, &block)
     @setter = setter || block
   end
-
 end

data/lib/volt/server/html_parser/view_scope.rb

@@ -67,7 +67,7 @@ class ViewScope
   end
 
   def add_each(content)
-    @handler.scope << EachScope.new(@handler, @path, content)
+    @handler.scope << EachScope.new(@handler, @path + "/__each#{@binding_number}", content)
   end
 
   def add_template(content)

data/lib/volt/server/socket_connection_handler.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'sockjs/session'
+require File.join(File.dirname(__FILE__), "../../../app/volt/tasks/query_tasks")
 
 class SocketConnectionHandler < SockJS::Session
   # Create one instance of the dispatcher

data/spec/server/html_parser/view_parser_spec.rb

@@ -114,7 +114,7 @@ describe ViewParser do
     view = ViewParser.new(html, "main/main/main")
 
     expect(view.templates).to eq({
-      "main/main/main/body/__template/0" => {
+      "main/main/main/body/__each0/__template/0" => {
         "html" => "\n          <p><!-- $0 --><!-- $/0 --></p>\n        ",
         "bindings" => {
           0 => [
@@ -126,7 +126,7 @@ describe ViewParser do
         "html" => "      <div class=\"main\">\n        <!-- $0 --><!-- $/0 -->\n      </div>\n",
         "bindings" => {
           0 => [
-            "lambda { |__p, __t, __c, __id| EachBinding.new(__p, __t, __c, __id, Proc.new { _items }, \"item\", \"main/main/main/body/__template/0\") }"
+            "lambda { |__p, __t, __c, __id| EachBinding.new(__p, __t, __c, __id, Proc.new { _items }, \"item\", \"main/main/main/body/__each0/__template/0\") }"
           ]
         }
       }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: volt
 version: !ruby/object:Gem::Version
-  version: 0.7.18
+  version: 0.7.19
 platform: ruby
 authors:
 - Ryan Stout
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-06 00:00:00.000000000 Z
+date: 2014-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor