volt 0.5.18 → 0.6.0

data/lib/volt/extra_core/extra_core.rb

@@ -1,4 +1,5 @@
 require 'volt/extra_core/array'
+require 'volt/extra_core/hash'
 require 'volt/extra_core/object'
 require 'volt/extra_core/blank'
 require 'volt/extra_core/stringify_keys'

data/lib/volt/extra_core/hash.rb

@@ -0,0 +1,11 @@
+class Hash
+  def deep_cur
+    new_hash = {}
+    
+    each_pair do |key, value|
+      new_hash[key.deep_cur] = value.deep_cur
+    end
+    
+    return new_hash
+  end
+end

data/lib/volt/extra_core/object.rb

@@ -33,4 +33,8 @@ class Object
       __send__(*a, &b)
     end
   end
+  
+  def deep_cur
+    self.cur
+  end
 end

data/lib/volt/models/array_model.rb

@@ -20,6 +20,42 @@ class ArrayModel < ReactiveArray
     @persistor.loaded if @persistor
   end
   
+  # For stored items, tell the collection to load the data when it 
+  # is requested.
+  def [](index)
+    load_data
+    super
+  end
+  
+  def size
+    load_data
+    super
+  end
+  
+  def state
+    if @persistor
+      @persistor.state
+    else
+      :loaded
+    end
+  end
+  
+  def loaded?
+    state == :loaded
+  end
+  
+  tag_method(:find) do
+    destructive!
+    pass_reactive!
+  end
+  def find(*args)
+    if @persistor
+      return @persistor.find(*args)
+    else
+      raise "this model's persistance layer does not support find, try using store"
+    end
+  end
+  
   def attributes
     self
   end
@@ -63,6 +99,17 @@ class ArrayModel < ReactiveArray
     return array
   end
   
+  def inspect
+    if @persistor && @persistor.is_a?(Persistors::ArrayStore) && state == :not_loaded
+      # Show a special message letting users know it is not loaded yet.
+      return "#<#{self.class.to_s}:not loaded, access with [] or size to load>"
+    end
+
+    # Otherwise inspect normally
+    super
+  end
+  
+  
   private
     # Takes the persistor if there is one and
     def setup_persistor(persistor)
@@ -70,4 +117,13 @@ class ArrayModel < ReactiveArray
         @persistor = persistor.new(self)
       end
     end
+    
+    # Loads data in an array store persistor when data is requested.
+    def load_data
+      if @persistor && @persistor.is_a?(Persistors::ArrayStore)
+        @persistor.load_data
+      end
+    end
+  
+    
 end

data/lib/volt/models/model.rb

@@ -51,16 +51,7 @@ class Model
   def !
     !attributes
   end
-  
-  # Pass to the persisotr
-  def event_added(event, scope_provider, first)
-    @persistor.event_added(event, scope_provider, first) if @persistor
-  end
-  
-  # Pass to the persistor
-  def event_removed(event, no_more_events)
-    @persistor.event_removed(event, no_more_events) if @persistor
-  end
+
   
   tag_all_methods do
     pass_reactive! do |method_name|
@@ -204,7 +195,11 @@ class Model
   
   def inspect
     "<#{self.class.to_s} #{attributes.inspect}>"
-  end  
+  end
+  
+  def deep_cur
+    attributes
+  end
   
   private
     # Clear the previous value and assign a new one

data/lib/volt/models/model_helpers.rb

@@ -1,3 +1,5 @@
+# A place for things shared between an ArrayModel and a Model
+
 module ModelHelpers
   def deep_unwrap(value)
     if value.is_a?(Model)
@@ -8,4 +10,14 @@ module ModelHelpers
     
     return value
   end
+  
+  # Pass to the persisotr
+  def event_added(event, scope_provider, first)
+    @persistor.event_added(event, scope_provider, first) if @persistor
+  end
+  
+  # Pass to the persistor
+  def event_removed(event, no_more_events)
+    @persistor.event_removed(event, no_more_events) if @persistor
+  end
 end

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

@@ -1,46 +1,145 @@
 require 'volt/models/persistors/store'
+require 'volt/models/persistors/query/query_listener_pool'
 
 module Persistors
   class ArrayStore < Store
+    @@query_pool = QueryListenerPool.new
+    
+    attr_reader :model
+    attr_accessor :state
+    
+    def self.query_pool
+      @@query_pool
+    end
+    
+    def initialize(model, tasks=nil)
+      super
+      
+      @query = ReactiveValue.from_hash(@model.options[:query] || {})
+      
+    end
     
     # Called when a collection loads
     def loaded
-      scope = {}
+      change_state_to :not_loaded
+    end
     
+    def event_added(event, scope_provider, first)
+      puts "ADD EV: #{event} - #{first}"
+      # First event, we load the data.
+      load_data if first
+    end
     
+    def event_removed(event, no_more_events)
+      # Remove listener where there are no more events on this model
+      if no_more_events && @query_listener && @model.listeners.size == 0
+        stop_listening
+      end
+    end
     
-      # Scope to the parent
-      if @model.path.size > 1
-        parent = @model.parent
+    # Called when an event is removed and we no longer want to keep in
+    # sync with the database.
+    def stop_listening
+      @query_listener.remove_store(self)
+      @query_listener = nil
+
+      change_state_to :dirty
+    end
+
+    # Called from the QueryListener when the data is loaded
+    def change_state_to(new_state)
+      @state = new_state
+      
+      # Trigger changed on the 'state' method
+      @model.trigger_for_methods!('changed', :state, :loaded?)
+    end
+
+    # Called the first time data is requested from this collection
+    def load_data
+      # Don't load data from any queried
+      if @state == :not_loaded || @state == :dirty
+        puts "Load Data"
+        change_state_to :loading
         
-        parent.persistor.ensure_setup if parent.persistor
-        puts @model.parent.inspect
+        @query_changed_listener.remove if @query_changed_listener
+        if @query.reactive?
+          # Query might change, change the query when it does
+          @query_changed_listener = @query.on('changed') do
+            stop_listening
+            
+            load_data
+          end
+        end
         
+        puts "QUERY: #{@query.deep_cur.inspect}"
+
+        run_query(@model, @query.deep_cur)
+      end
+    end
+    
+    # Clear out the models data, since we're not listening anymore.
+    def unload_data
+      change_state_to :not_loaded
+      @model.clear
+    end
+    
+    def run_query(model, query={})
+      collection = model.path.last
+      # Scope to the parent
+      if model.path.size > 1
+        parent = model.parent
+      
+        parent.persistor.ensure_setup if parent.persistor
+      
         if parent && (attrs = parent.attributes) && attrs[:_id].true?
-          scope[:"#{@model.path[-3].singularize}_id"] = attrs[:_id]
+          query[:"#{model.path[-3].singularize}_id"] = attrs[:_id]
         end
       end
+
+      @query_listener = @@query_pool.lookup(collection, query) do
+        # Create if it does not exist
+        QueryListener.new(@@query_pool, @tasks, collection, query)
+      end
+      @query_listener.add_store(model.persistor)
+    end
+    
+    def find(query={})
+      model = ArrayModel.new([], @model.options.merge(:query => query))
+      
+      return ReactiveValue.new(model)
+    end
+    
+    # Called from backend
+    def add(index, data)
+      $loading_models = true
+      
+      new_options = @model.options.merge(path: @model.path + [:[]], parent: @model)
       
-      puts "Load At Scope: #{scope.inspect}"
+      # Find the existing model, or create one
+      new_model = @@identity_map.find(data['_id']) { Model.new(data.symbolize_keys, new_options) }
       
-      query(scope)
+      @model.insert(index, new_model)
       
-      change_channel_connection('add', 'added')
-      change_channel_connection('add', 'removed')
+      $loading_models = false      
     end
     
-    def query(query)
-      @tasks.call('StoreTasks', 'find', @model.path.last, query) do |results|
-        # TODO: Globals evil, replace
-        $loading_models = true
+    def remove(ids)
+      $loading_models = true
+      ids.each do |id|
+        puts "delete at: #{id} on #{@model.inspect}"
         
-        new_options = @model.options.merge(path: @model.path + [:[]], parent: @model)
-        
-        results.each do |result|
-          @model << Model.new(result, new_options)
+        # TODO: optimize this delete so we don't need to loop
+        @model.each_with_index do |model, index|
+          puts "#{model._id.inspect} vs #{id.inspect} - #{index}"
+          if model._id == id
+            del = @model.delete_at(index)
+            puts "DELETED AT #{index}: #{del.inspect} - #{@model.inspect}"
+            break
+          end
         end
-        $loading_models = false
       end
+      
+      $loading_models = false
     end
     
     def channel_name
@@ -50,7 +149,7 @@ module Persistors
     
     # When a model is added to this collection, we call its "changed"
     # method.  This should trigger a save.
-    def added(model)
+    def added(model, index)
       unless defined?($loading_models) && $loading_models
         model.persistor.changed
       end

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

@@ -0,0 +1,12 @@
+require 'volt/utils/generic_counting_pool'
+
+# The identity map ensures that there is only one copy of a model
+# used on the front end at a time.
+class ModelIdentityMap < GenericCountingPool  
+  # add extends GenericCountingPool so it can add in a model without
+  # a direct lookup.  We use this when we create a model (without an id)
+  # then save it and it gets assigned an id.
+  def add(id, model)
+    @pool[id] = [1, model]
+  end
+end

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

@@ -1,12 +1,18 @@
 require 'volt/models/persistors/store'
 
+
 module Persistors
   class ModelStore < Store
     ID_CHARS = [('a'..'z'), ('A'..'Z'), ('0'..'9')].map {|v| v.to_a }.flatten
-  
-    @@identity_map = {}
     
     attr_reader :model
+    attr_accessor :in_identity_map
+    
+    def initialize(model, tasks)
+      super
+      
+      @in_identity_map = false
+    end
     
     def add_to_collection
       @in_collection = true
@@ -16,7 +22,6 @@ module Persistors
     
     def remove_from_collection
       @in_collection = false
-      stop_listening_for_changes
     end
     
     # Called the first time a value is assigned into this model
@@ -24,21 +29,18 @@ module Persistors
       if @model.attributes
         @model.attributes[:_id] ||= generate_id
 
-        if !model_in_identity_map?
-          @@identity_map[@model.attributes[:_id]] ||= self
-        end
-
-        # Check to see if we already have listeners setup
-        if @model.listeners[:changed]
-          listen_for_changes
-        end
+        add_to_identity_map
       end
     end
     
-    def model_in_identity_map?
-      @@identity_map[@model.attributes[:_id]]
+    def add_to_identity_map
+      unless @in_identity_map
+        @@identity_map.add(@model._id, @model)
+        
+        @in_identity_map = true
+      end      
     end
-    
+
     # Create a random unique id that can be used as the mongo id as well
     def generate_id
       id = []
@@ -63,67 +65,25 @@ module Persistors
       end
     end
 
-    def listen_for_changes
-      unless @change_listening
-        if @in_collection
-          @change_listening = true
-          change_channel_connection("add")
-        end
-      end
-    end
-    
-    def stop_listening_for_changes
-      if @change_listening
-        @change_listening = false
-        change_channel_connection("remove")
-      end
-    end
-
     def event_added(event, scope_provider, first)
       if first && event == :changed
-        # Start listening
         ensure_setup
-        listen_for_changes
       end
     end
-  
-    def event_removed(event, no_more_events)
-      if no_more_events && event == :changed
-        # Stop listening
-        stop_listening_for_changes
-      end
-    end
-
-    def channel_name
-       @channel_name ||= "#{@model.path[-2]}##{@model.attributes[:_id]}"
-    end
-    
-    # Finds the model in its parent collection and deletes it.
-    def delete!
-      if @model.path.size == 0
-        raise "Not in a collection"
-      end
-    
-      @model.parent.delete(@model)
-    end
     
     # Update the models based on the id/identity map.  Usually these requests
     # will come from the backend.
-    def self.update(model_id, data)
-      persistor = @@identity_map[model_id]
+    def self.changed(model_id, data)
+      model = @@identity_map.lookup(model_id)
     
-      if persistor
+      if model
         data.each_pair do |key, value|
           if key != '_id'
-            persistor.model.send(:"#{key}=", value)
+            model.send(:"#{key}=", value)
           end
         end
       end
     end
-    
-    def self.from_id(id)
-      @@identity_map[id]
-    end
 
     private
       # Return the attributes that are only for this store, not any sub-associations.