volt 0.5.18 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 772c4d0aaa812cfcf06f57870866fb11a7048e5f
-  data.tar.gz: 2acf6521c5efa480cb06857becb68133cce953c5
+  metadata.gz: b53ad931d8386ec350af55adf688c865a96021aa
+  data.tar.gz: db65b8addb0e41e518cc1494a0a75fdee4afc84a
 SHA512:
-  metadata.gz: 34531249996f8ef4b435c60b70d08fdccc1558049f669ea19c738ce5bf05b8c7d6ea9452b1ca0e135d5d472be3d5cd7bdc45a550c044a54f6597d8e2f0fbc80f
-  data.tar.gz: b6d154d43b4226306965eed1aa8b04b4b15891b5c4c133dac70a0565e838d058203b9bd15a6b77810b73b1d1d55aa6b4c20e6e862b96c48256352cc5d7fc47ab
+  metadata.gz: 6b32dffb18e5e0e0052c71c15f7d3540fd1d7bcabb0d3c04d6b8187d4ec40044b4746fdb87a53a271c91bffad9a25cf49fc8bd1e3928bf4916ce839823b34594
+  data.tar.gz: 97d1d0c43d453482904cff905109192dccdfb18a388fddc5fa285e1958241802da9b64aeb6ed652d801d1d5aac6c4f1ad2d1c2ec6e932eb7dfd0de7117d61373

data/Readme.md

@@ -196,6 +196,8 @@ 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.
 
+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.
+
 ### 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.
@@ -689,3 +691,15 @@ Controllers provide a .channel method, that you can use to get the status of the
 ## Accessing DOM section in a controller
 
 TODO
+
+
+# Data Store
+
+**Work in process**
+
+| state       | events bound | description                                                  |
+|-------------|--------------|--------------------------------------------------------------|
+| not_loaded  | no           | no events and no one has accessed the data in the model      |
+| 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. |

data/VERSION

@@ -1 +1 @@
-0.5.18
+0.6.0

data/app/volt/controllers/notices_controller.rb

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

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

@@ -0,0 +1,12 @@
+require 'mongo'
+
+class DataStore
+  def initialize
+    @@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

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

@@ -0,0 +1,86 @@
+require_relative 'query_tracker'
+
+# 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! 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

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

@@ -0,0 +1,36 @@
+require_relative 'live_query'
+require 'volt/utils/generic_pool'
+
+class LiveQueryPool < GenericPool
+  def initialize(data_store)
+    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.
+    def create(collection, query)
+      # 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

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

@@ -0,0 +1,95 @@
+# The query tracker runs queries and then tracks the changes
+# that take place.
+class QueryTracker
+  attr_accessor :results
+  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)
+    if @previous_ids
+      detect_removed(skip_channel)
+
+      detect_added_and_moved(skip_channel)
+
+      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)
+    previous_index = 0
+    @current_ids.each_with_index do |id,index|
+      if (cur_previous = @previous_ids[previous_index]) && cur_previous == id
+        # Same in both previous and new
+        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
+        data = @results_hash[id]
+        @live_query.notify_added(index, data, skip_channel)
+      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
+        @live_query.notify_changed(id, data, skip_channel)
+      end
+    end
+  end
+
+end

data/app/volt/tasks/query_tasks.rb

@@ -0,0 +1,57 @@
+require_relative 'live_query/data_store'
+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 
+  # 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)
+      @@channel_live_queries[@channel] ||= []
+      @@channel_live_queries[@channel] << live_query
+    end
+
+
+end

data/app/volt/tasks/store_tasks.rb

@@ -1,5 +1,4 @@
 require 'mongo'
-require_relative 'channel_tasks'
 
 class StoreTasks
   def initialize(channel=nil, dispatcher=nil)
@@ -15,7 +14,7 @@ class StoreTasks
   end
   
   def save(collection, data)
-    puts "Insert: #{data.inspect} on #{collection.inspect}"
+    # puts "Insert: #{data.inspect} on #{collection.inspect}"
     
     data = data.symbolize_keys
     id = data[:_id]
@@ -24,10 +23,6 @@ class StoreTasks
     # TODO: Seems mongo is dumb and doesn't let you upsert with custom id's
     begin
       @@db[collection].insert(data)
-      
-      # Message that we inserted a new item
-      puts "SENDING DATA: #{data.inspect}"
-      ChannelTasks.send_message_to_channel("#{collection}-added", ['added', nil, collection, data], @channel)
     rescue Mongo::OperationFailure => error
       # Really mongo client?
       if error.message[/^11000[:]/]
@@ -40,21 +35,13 @@ class StoreTasks
       end
     end
     
-
-    ChannelTasks.send_message_to_channel("#{collection}##{id}", ['changed', nil, id, data], @channel)
-  end
-  
-  def find(collection, scope, query=nil)
-    results = @@db[collection].find(scope).to_a.map {|item| item.symbolize_keys }
-    puts "FIND: #{collection.inspect} - #{scope} - #{results.inspect}"
-    
-    return results
+    QueryTasks.live_query_pool.updated_collection(collection, @channel)
   end
-  
+
   def delete(collection, id)
     puts "DELETE: #{collection.inspect} - #{id.inspect}"
     @@db[collection].remove('_id' => id)
     
-    ChannelTasks.send_message_to_channel("#{collection}-removed", ['removed', nil, id], @channel)
+    QueryTasks.live_query_pool.updated_collection(collection, @channel)
   end
 end

data/lib/volt.rb

@@ -1,4 +1,6 @@
 require 'volt/volt/environment'
+require 'volt/extra_core/extra_core'
+require 'volt/reactive/reactive_value'
 
 class Volt
   def self.root

data/lib/volt/console.rb

@@ -5,7 +5,7 @@ class Console
     $LOAD_PATH << 'lib'
     ENV['SERVER'] = 'true'
 
-    require 'volt/extra_core/extra_core'
+    require 'volt'
     require 'volt/models'
     require 'volt/server/template_parser'
     require 'volt'

data/lib/volt/controllers/model_controller.rb

@@ -33,6 +33,10 @@ class ModelController
   def page
     $page.page
   end
+  
+  def paged
+    $page.page
+  end
 
   def store
     $page.store

data/lib/volt/extra_core/array.rb

@@ -7,4 +7,13 @@ class Array
     
     return total
   end
+  
+  def deep_cur
+    new_array = []
+    each do |item|
+      new_array << item.deep_cur
+    end
+    
+    return new_array
+  end
 end