volt 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d799deb4ea372c6d37040e23d0e7317e1bae2820
-  data.tar.gz: 1590f92d018a6344c3b60a9e10720135c6c0a27e
+  metadata.gz: 7a2b3f88f704f2e2438faffed5fc2039fa2ba4c2
+  data.tar.gz: 5030c30dbc621f0ceb393b8fad31abdab9cff17c
 SHA512:
-  metadata.gz: d5a64ae3a5d148e115725f9a0fa2cc172df77f39e3c483896004b8683427df769b49fffb21de18b10aac7097dccf5ac563a7bd5444b65e114e98735913e9707a
-  data.tar.gz: 858c561299e391deb865d4be3017110f55e7890a9bcc716c609d5f18c350f93dec900c97ee888164a106f90b4df924c5b91709e885324984e4ac2a8195de295f
+  metadata.gz: 7f88181450bad8a2aa0552a0bc52e69f5c0c1c5901e8f2f44edacf80b9f98dd92ca87345f90b51615955451af41d8089010f2e7e5ee5d99ccc9ed8789efd2cb8
+  data.tar.gz: e4b3a917332a57e3d524129c817787246b76ba78333b305c942c2fccf393d49981b6e4a0c28e48aaf60f4e91212dc5a869341e031cb1c28fb9b44cc4e2453609

data/Readme.md

@@ -2,15 +2,17 @@
 [![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
+---
+> NOTE: VOLT IS STILL IN DEVELOPMENT, DON'T USE IT FOR ANYTHING SERIOUS YET
+---
 
-NOTE: VOLT IS STILL IN DEVELOPMENT, DON'T USE IT FOR ANYTHING SERIOUS YET
+# 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.
 
 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)
 
-Pages HTML is written in a handlebars like template language.  Volt uses data flow/reactive programming to automatically and intellegently propigate changes to the dom (or anything other code wanting to know when a value updates)  When something in the dom changes, Volt intellegent 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 intellegently propigate 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 a quick demo video here: [http://www.youtube.com/watch?v=j0vFIRMzarI](http://www.youtube.com/watch?v=j0vFIRMzarI)
 
@@ -51,7 +53,7 @@ To get started, install volt:
 Then create a new project:
 
     volt new project_name
-    
+
 This will setup a basic project.  Now lets run the server.
 
     volt server
@@ -126,17 +128,17 @@ When you call a method on a ReactiveValue, you get back a new reactive value tha
     a = ReactiveValue.new(1)
     a.reactive?
     # => true
-    
+
     a.cur
     # => 1
-    
+
     b = a + 5
     b.reactive?
     # => true
-    
+
     b.cur
     # => 6
-    
+
     a.cur = 2
     b.cur
     # => 7
@@ -159,14 +161,14 @@ These events propigate to any reactive value's created off of a reactive value.
     a = ReactiveValue.new(1)
     b = a + 5
     b.on('changed') { puts "B changed" }
-    
+
     a.trigger!('changed')
     # => B changed
 ```
 
 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 propigate 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 value's as arguments to methods on a reactive value.  The dependencies will be tracked for both and events will propigate down from both.  (Also, note that doing `.cur =` to update the current value triggers a "changed" event.)
 
 ```ruby
     a = ReactiveValue.new(1)
@@ -176,11 +178,11 @@ Lastly, we can also pass in other reactive value's as arguments to methods on a
     a.on('changed') { puts "A changed" }
     b.on('changed') { puts "B changed" }
     c.on('changed') { puts "C changed" }
-    
+
     a.cur = 3
     # => A changed
     # => C changed
-    
+
     b.cur = 5
     # => B changed
     # => C changed
@@ -208,14 +210,14 @@ Because a method on a reactive value always returns another reactive value, and
 
 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.
 
-Instead of 
+Instead of
 
 ```ruby
     a || b
 ```
 
 Simply use:
-    
+
 ```ruby
     a.or(b)
 ```
@@ -255,7 +257,7 @@ An if binding lets you provide basic flow control.
     {#if _some_check?}
       <p>render this</p>
     {/}
-    
+
 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.
@@ -305,7 +307,7 @@ Bindings can also be placed inside of attributes.
 There are some special features provided to make for elements work as "two way bindings"
 
     <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.
 
     <input type="checkbox" checked="{_checked}" />
@@ -327,7 +329,7 @@ Volt comes with many built-in models, one is called 'page'.  If you call #page o
     page._name
     # => @'Ryan'
 ```
-    
+
 Models act like a hash that you can access with getters and setters that start with an _  Prefixing with an underscore makes sure we don't accidentally try to call a method that doesn't exist and get back nil.  There is no need to define which fields a model has, they act similar to a hash, but with a shorter access and assign syntax.
 
 Models also let you nest data:
@@ -336,11 +338,11 @@ Models also let you nest data:
     page._settings._color = 'blue'
     page._settings._color
     # => @'blue'
-    
+
     page._settings
     # => @#<Model:_settings {:_color=>"blue"}>
 ```
-    
+
 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.
@@ -349,7 +351,7 @@ You can also append to a model if its not defined yet.
     page._items << 'item 1'
     page._items
     # => @#<ArrayModel ["item 1", "item 2"]>
-    
+
     page._items[0]
     # => @"item 1"
 ```
@@ -381,11 +383,11 @@ Models trigger events when their data is updated.  Currently models emit three e
 
 ```ruby
     model = Model.new
-    
+
     model._name.on('changed') { puts 'name changed' }
     model._name = 'Ryan'
     # => name changed
-    
+
     model._items.on('added') { puts 'item added' }
     model._items << 1
     # => item added
@@ -408,15 +410,15 @@ For convience, when placing a hash inside of another model, it is automatically
       twitter: 'http://www.twitter.com/ryanstout',
       dribbble: 'http://dribbble.com/ryanstout'
     }
-    
+
     user._name
     # => "Ryan"
     user._profiles._twitter
     # => "http://www.twitter.com/ryanstout"
     user._profiles.class
     # => 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.
 
 You can get a ruby hash back out by calling .to_h on a Model.
@@ -430,11 +432,11 @@ Arrays inside of models are automatically converted to an instance of ArrayModel
     model._items << {_name: 'item 1'}
     model._items.class
     # => ArrayModel
-    
+
     model._items[0].class
     # => Model
     model._items[0]
-```    
+```
 
 
 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).
@@ -446,10 +448,10 @@ To convert a Model or an ArrayModel back to a normal hash, call .to_h or .to_a r
       twitter: 'http://www.twitter.com/ryanstout',
       dribbble: 'http://dribbble.com/ryanstout'
     }
-    
+
     user._profiles.to_h
     # => {twitter: 'http://www.twitter.com/ryanstout', dribbble: 'http://dribbble.com/ryanstout'}
-    
+
     items = ArrayModel.new([1,2,3,4])
     items
 ```
@@ -465,13 +467,13 @@ A controller can be any class in Volt, however it is common to have that class i
 ```ruby
     class TodosController < ModelController
       model :page
-  
+
       # ...
     end
 ```
 
 This can also be done at anytime on the controller instance:
-    
+
 ```ruby
     class TodosController < ModelController
       def initialize
@@ -479,7 +481,7 @@ This can also be done at anytime on the controller instance:
       end
     end
 ```
-    
+
 See the [provided collections](#provided-collections) section for a list of the available collection models.
 
 You can also provide your own object to model.
@@ -518,7 +520,7 @@ Sometimes you may need to include an externally hosted JS file from a component.
     javascript_file 'http://code.jquery.com/jquery-2.0.3.min.js'
     css_file '//netdna.bootstrapcdn.com/bootstrap/3.0.3/css/bootstrap.min.css'
 ```
-    
+
 Note above though that jquery and bootstrap are currently included by default.  Using javascript_file and css_file will be mixed in with your component assets at the correct locations according to the order they occur in the dependencies.rb files.
 
 ## Assets
@@ -561,13 +563,13 @@ Volt automatically places ```<:volt:notices />``` into views.  This shows notice
 
 As part of the notices component explained above, you can append messages to any collection on the flash model.
 
-Each collection represents a different type of "flash".  Common examples are ```_notices, _warnings, and _errors```  Using different collections allows you to change how you want the flash displayed.  For example, you might want ```_notices``` and ```_errors``` to show with different colors. 
+Each collection represents a different type of "flash".  Common examples are ```_notices, _warnings, and _errors```  Using different collections allows you to change how you want the flash displayed.  For example, you might want ```_notices``` and ```_errors``` to show with different colors.
 
 ```ruby
     flash._notices << "message to flash"
 ```
 
-These messages will show for 5 seconds, then disappear (both from the screen and the collection). 
+These messages will show for 5 seconds, then disappear (both from the screen and the collection).
 
 # Controls
 
@@ -578,7 +580,7 @@ To render a control, simply use a tag like so:
 ```html
     <:control-name />
 ```
-    
+
 or
 
 ```html
@@ -602,7 +604,7 @@ To find the control's views and optional controller, Volt will search the follow
 Each part is explained below:
 
 1. section
-Views are composed of sections.  Sections start with a ```<:SectionName>``` tag and end with ```</:SectionName>```  Volt will look first for a section in the same view.
+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.
@@ -621,7 +623,7 @@ When you create a control, you can also specify multiple parts of the search pat
 ```html
     <:blog:comments />
 ```
-    
+
 The above would search the following:
 
 | Component   | View Folder    | View File    | Section   |
@@ -659,7 +661,7 @@ Route path's can also contain variables similar to bindings.
 ```ruby
     get "/todos/{_index}", _view: 'todos'
 ```
-    
+
 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.
@@ -671,7 +673,7 @@ Routes are matched top to bottom in a routes file.
 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:
 
     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)
 
 
@@ -710,3 +712,8 @@ store._things
 | loading     | maybe        | someone either accessed the data or bound an event           |
 | loaded      | yes          | data is loaded and there is an event bound                   |
 | dirty       | no           | data was either accessed without binding an event, or an event was bound, but later unbound. |
+
+
+# Why Volt is Awesome
+
+- only the relevant dom is updated.  There is no match and patch algorithm to update from strings like other frameworks, all associations are tracked through our reactive values, so we know exactly what needs to be updated without the need to generate any extra html.  This has a few advantages, namely that things like input fields are retained, so any properties (focus, tab position, etc...) are also retained.

data/VERSION

@@ -1 +1 @@
-0.6.5
+0.7.0

data/app/volt/controllers/notices_controller.rb

@@ -1,13 +1,13 @@
 class Volt
   class NoticesController < ModelController
     model :page
-    
+
     def hey
       "yep"
     end
-    
+
     def page
       $page.page
     end
   end
-end
+end

data/app/volt/tasks/live_query/data_store.rb

@@ -5,8 +5,8 @@ class DataStore
     @@mongo_db ||= Mongo::MongoClient.new("localhost", 27017)
     @@db ||= @@mongo_db.db("development")
   end
-  
+
   def query(collection, query)
     @@db[collection].find(query).to_a
   end
-end
+end

data/app/volt/tasks/live_query/live_query.rb

@@ -1,86 +1,86 @@
 require_relative 'query_tracker'
 
-# Tracks a channel and a query on a collection.  Alerts 
+# Tracks a channel and a query on a collection.  Alerts
 # the listener when the data in the query changes.
 class LiveQuery
   attr_reader :current_ids, :collection, :query
-  
+
   def initialize(pool, data_store, collection, query)
     @pool = pool
     @collection = collection
     @query = query
-    
+
     @channels = []
     @data_store = data_store
-    
+
     @query_tracker = QueryTracker.new(self, @data_store)
-    
+
     run
   end
-  
+
   def run(skip_channel=nil)
     @query_tracker.run(skip_channel)
   end
-  
+
   def notify_removed(ids, skip_channel)
     notify! do |channel|
       # puts "Removed: #{ids.inspect} to #{channel.inspect}"
       channel.send_message("removed", nil, @collection, @query, ids)
     end
   end
-  
+
   def notify_added(index, data, skip_channel)
     notify!(skip_channel) do |channel|
       # puts "Added: #{index} - #{data.inspect} to #{channel.inspect}"
       channel.send_message("added", nil, @collection, @query, index, data)
     end
   end
-  
+
   def notify_moved(id, new_position, skip_channel)
     notify! do |channel|
       # puts "Moved: #{id}, #{new_position} to #{channel.inspect}"
       channel.send_message("moved", nil, @collection, @query, id, new_position)
     end
   end
-  
+
   def notify_changed(id, data, skip_channel)
     notify!(skip_channel) do |channel|
       # puts "Changed: #{id}, #{data} to #{channel.inspect}"
       channel.send_message("changed", nil, @collection, @query, id, data)
     end
   end
-  
-  
+
+
   # return the query results the first time a channel connects
   def initial_data
     @query_tracker.results.map.with_index {|data, index| [index, data] }
   end
-  
+
   def add_channel(channel)
     @channels << channel
   end
-  
+
   def remove_channel(channel)
     @channels.delete(channel)
-    
+
     if @channels.size == 0
       # remove this query, no one is listening anymore
       @pool.remove(@collection, @query)
     end
   end
-  
+
   def notify!(skip_channel=nil, only_channel=nil)
     if only_channel
       channels = [only_channel]
     else
       channels = @channels
     end
-    
+
     channels = channels.reject {|c| c == skip_channel }
-    
+
     channels.each do |channel|
       yield(channel)
     end
   end
-  
-end
+
+end

data/app/volt/tasks/live_query/live_query_pool.rb

@@ -6,20 +6,20 @@ class LiveQueryPool < GenericPool
     super()
     @data_store = data_store
   end
-  
+
   def lookup(collection, query)
     query = normalize_query(query)
-    
+
     return super(collection, query)
   end
-  
+
   def updated_collection(collection, skip_channel)
     lookup_all(collection).each do |live_query|
       # puts "RUN ON: #{live_query} with #{live_query.instance_variable_get('@channels').inspect}"
       live_query.run(skip_channel)
     end
   end
-  
+
   private
     # Creates the live query if it doesn't exist, and stores it so it
     # can be found later.
@@ -27,10 +27,10 @@ class LiveQueryPool < GenericPool
       # If not already setup, create a new one for this collection/query
       return LiveQuery.new(self, @data_store, collection, query)
     end
-  
+
     def normalize_query(query)
       # TODO: add something to sort query properties so the queries are
       # always compared the same.
       return query
     end
-end
+end

data/app/volt/tasks/live_query/query_tracker.rb

@@ -5,29 +5,29 @@ class QueryTracker
   def initialize(live_query, data_store)
     @live_query = live_query
     @data_store = data_store
-    
+
     # Stores the list of id's currently associated with this query
     @current_ids = []
     @results = []
     @results_hash = {}
   end
-  
+
   # Runs the query, stores the results and updates the current_ids
   def run(skip_channel=nil)
     @previous_results = @results
     @previous_results_hash = @results_hash
     @previous_ids = @current_ids
-    
+
     # Run the query again
     @results = @data_store.query(@live_query.collection, @live_query.query)
-    
+
     # Update the current_ids
     @current_ids = @results.map {|r| r['_id'] }
     @results_hash = Hash[@results.map {|r| [r['_id'], r] }]
-    
+
     process_changes(skip_channel)
   end
-  
+
   # Looks at the changes in the last run and sends out notices
   # all changes.
   def process_changes(skip_channel)
@@ -39,18 +39,18 @@ class QueryTracker
       detect_changed(skip_channel)
     end
   end
-  
+
   def detect_removed(skip_channel)
     # Removed models
     removed_ids = @previous_ids - @current_ids
     if removed_ids.size > 0
       @live_query.notify_removed(removed_ids, skip_channel)
     end
-    
+
     # Update @previous_ids to relect the removed
     @previous_ids = @previous_ids & @current_ids
   end
-  
+
   # Loop through the new list, tracking in the old, notifies of any that
   # have been added or moved.
   def detect_added_and_moved(skip_channel)
@@ -61,15 +61,15 @@ class QueryTracker
         previous_index += 1
         next
       end
-      
+
       # We have an item that didn't match the current position's previous
       # TODO: make a hash so we don't have to do include?
       if @previous_ids.include?(id)
         # The location from the previous has changed, move to correct location.
-        
+
         # Remove from previous_ids, since it will be moved and we will be past it.
         @previous_ids.delete(id)
-        
+
         @live_query.notify_moved(id, index, skip_channel)
       else
         # TODO: Faster lookup
@@ -78,12 +78,12 @@ class QueryTracker
       end
     end
   end
-  
+
   # Finds all items in the previous results that have new values, and alerts
   # of changes.
   def detect_changed(skip_channel)
     not_added_or_removed = @previous_ids & @current_ids
-    
+
     not_added_or_removed.each do |id|
       if @previous_results_hash[id] != (data = @results_hash[id])
         # Data hash changed
@@ -92,4 +92,4 @@ class QueryTracker
     end
   end
 
-end
+end

data/app/volt/tasks/query_tasks.rb

@@ -4,48 +4,48 @@ require_relative 'live_query/live_query_pool'
 class QueryTasks
   @@live_query_pool = LiveQueryPool.new(DataStore.new)
   @@channel_live_queries = {}
-  
+
   def self.live_query_pool
     @@live_query_pool
   end
-    
+
   # The dispatcher passes its self in
   def initialize(channel, dispatcher=nil)
     @channel = channel
     @dispatcher = dispatcher
   end
-  
+
   def add_listener(collection, query)
     live_query = @@live_query_pool.lookup(collection, query)
     track_channel_in_live_query(live_query)
-    
+
     live_query.add_channel(@channel)
-    
+
     # Return the initial data
     return live_query.initial_data
   end
-  
-  # Remove a listening channel, the LiveQuery will automatically remove 
+
+  # Remove a listening channel, the LiveQuery will automatically remove
   # itsself from the pool when there are no channels.
   def remove_listener(collection, query)
     live_query = @@live_query_pool.lookup(collection, query)
     live_query.remove_channel(@channel)
   end
-  
-  
+
+
   # Removes a channel from all associated live queries
   def close!
     live_queries = @@channel_live_queries[@channel]
-    
+
     if live_queries
       live_queries.each do |live_query|
         live_query.remove_channel(@channel)
       end
     end
-    
+
     @@channel_live_queries.delete(@channel)
   end
-  
+
   private
     # Tracks that this channel will be notified from the live query.
     def track_channel_in_live_query(live_query)
@@ -54,4 +54,4 @@ class QueryTasks
     end
 
 
-end
+end