volt 0.5.18 → 0.6.0

data/lib/volt/models/persistors/query/query_listener.rb

@@ -0,0 +1,87 @@
+# The query listener is what gets notified on the backend when the results from
+# a query have changed.  It then will make the necessary changes to any ArrayStore's
+# to get them to display the new data.
+class QueryListener
+  def initialize(query_listener_pool, tasks, collection, query)
+    @query_listener_pool = query_listener_pool
+    @tasks = tasks
+    @stores = []
+    
+    @collection = collection
+    @query = query
+    
+    @listening = false
+  end
+  
+  def add_listener
+    @listening = true
+    @tasks.call('QueryTasks', 'add_listener', @collection, @query) do |results|
+      # When the initial data comes back, add it into the stores.
+      @stores.each do |store|
+        store.model.clear
+        results.each do |index, data|
+          store.add(index, data)
+        end
+        
+        store.change_state_to(:loaded)
+      end
+    end
+  end
+  
+  def add_store(store, &block)
+    puts "ADD STORE: #{store.inspect} - to #{self.inspect}"
+    @stores << store
+    
+    if @listening
+      # We are already listening and have this model somewhere else,
+      # copy the data from the existing model.
+      store.model.clear
+      @stores.first.model.each_with_index do |item, index|
+        store.add(index, item)
+      end
+    else
+      # First time we've added a store, setup the listener and get
+      # the initial data.
+      add_listener
+    end
+  end
+  
+  def remove_store(store)
+    @stores.delete(store)
+    
+    # When there are no stores left, remove the query listener from
+    # the pool, it can get created again later.
+    if @stores.size == 0
+      puts "OM"
+      @query_listener_pool.remove(@collection, @query)
+      puts "PM"
+      
+      # Stop listening
+      if @listening
+        @listening = false
+        puts "TOTAL REMOVE"
+        @tasks.call('QueryTasks', 'remove_listener', @collection, @query)        
+      end
+    end
+  end
+  
+  def added(index, data)
+    @stores.each do |store|
+      store.add(index, data)
+    end
+    puts "Added: #{index} - #{data.inspect}"
+  end
+  
+  def removed(ids)
+    @stores.each do |store|
+      store.remove(ids)
+    end
+  end
+  
+  def changed(model_id, data)
+    $loading_models = true
+    puts "From Backend: UPDATE: #{model_id} with #{data.inspect}"
+    Persistors::ModelStore.changed(model_id, data)
+    $loading_models = false
+  end
+end

data/lib/volt/models/persistors/query/query_listener_pool.rb

@@ -0,0 +1,9 @@
+require 'volt/utils/generic_pool'
+require 'volt/models/persistors/query/query_listener'
+
+# Keeps track of all query listeners, so they can be reused in different
+# places.  Dynamically generated queries may end up producing the same
+# query in different places.  This makes it so we only need to track a
+# single query at once.  Data updates will only be sent once as well.
+class QueryListenerPool < GenericPool 
+end

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

@@ -1,23 +1,21 @@
 require 'volt/models/persistors/base'
+require 'volt/models/persistors/model_identity_map'
 
 module Persistors
   class Store < Base
-    def initialize(model, tasks=nil)
-      @model = model
-      @is_tracking = false
-      @tasks = tasks
-    end
   
-    def change_channel_connection(add_or_remove, event=nil, scope=nil)
-      if (@model.attributes && @model.path.size > 1) || @model.is_a?(ArrayModel)
-        channel_name = self.channel_name.to_s
-        channel_name += "-#{event}" if event
-
-        puts "Event #{add_or_remove}: #{channel_name} -- #{@model.attributes.inspect}"
-        @tasks.call('ChannelTasks', "#{add_or_remove}_listener", channel_name, scope)
-      end
+    @@identity_map = ModelIdentityMap.new
+    
+    def initialize(model, tasks=nil)      
+      @tasks = tasks
+      @model = model
+      
+      @saved = false
     end
     
+    def saved?
+      @saved
+    end
 
     # On stores, we store the model so we don't have to look it up
     # every time we do a read.

data/lib/volt/models/url.rb

@@ -92,7 +92,7 @@ class URL
         # Scroll to anchor
         %x{
           var anchor = $('a[name="' + this.fragment + '"]');
-          if (anchor) {
+          if (anchor && anchor.length > 0) {
             $(document.body).scrollTop(anchor.offset().top);
           }
         }

data/lib/volt/page/bindings/attribute_binding.rb

@@ -2,9 +2,9 @@ require 'volt/page/bindings/base_binding'
 require 'volt/page/targets/attribute_target'
 
 class AttributeBinding < BaseBinding
-  def initialize(target, context, binding_name, attribute_name, getter)
+  def initialize(page, target, context, binding_name, attribute_name, getter)
     # puts "New Attribute Binding: #{binding_name}, #{attribute_name}, #{getter}"
-    super(target, context, binding_name)
+    super(page, target, context, binding_name)
 
     @attribute_name = attribute_name
     @getter = getter

data/lib/volt/page/bindings/base_binding.rb

@@ -1,7 +1,19 @@
+# The BaseBinding class is the base for all bindings.  It takes
+# 4 arguments that should be passed up from the children (via super)
+#
+# 1. page - this class instance should provide:
+#            - a #templates methods that returns a hash for templates
+#            - an #events methods that returns an instance of DocumentEvents
+# 2. target -  an DomTarget or AttributeTarget
+# 3. context - the context object the binding will be evaluated in
+# 4. binding_name - the id for the comment (or id for attributes) where the
+#                   binding will be inserted.  
 class BaseBinding
   attr_accessor :target, :context, :binding_name
 
-  def initialize(target, context, binding_name)
+  def initialize(page, target, context, binding_name)
+    # puts "NEW #{context.inspect} - #{self.inspect}"
+    @page = page
     @target = target
     @context = context
     @binding_name = binding_name

data/lib/volt/page/bindings/component_binding.rb

@@ -25,7 +25,7 @@ class ComponentBinding < TemplateBinding
       current_context = SubContext.new(model_with_parent, $page)
     end
 
-    @current_template = TemplateRenderer.new(@target, current_context, @binding_name, full_path)
+    @current_template = TemplateRenderer.new(@page, @target, current_context, @binding_name, full_path)
     
     call_ready
   end

data/lib/volt/page/bindings/content_binding.rb

@@ -1,9 +1,9 @@
 require 'volt/page/bindings/base_binding'
 
 class ContentBinding < BaseBinding
-  def initialize(target, context, binding_name, getter)
+  def initialize(page, target, context, binding_name, getter)
     # puts "new content binding: #{getter}"
-    super(target, context, binding_name)
+    super(page, target, context, binding_name)
 
     # Find the source for the content binding
     @value = value_from_getter(getter)

data/lib/volt/page/bindings/each_binding.rb

@@ -1,10 +1,10 @@
 require 'volt/page/bindings/base_binding'
 
 class EachBinding < BaseBinding
-  def initialize(target, context, binding_name, getter, variable_name, template_name)
+  def initialize(page, target, context, binding_name, getter, variable_name, template_name)
     # puts "New EACH Binding"
 
-    super(target, context, binding_name)
+    super(page, target, context, binding_name)
 
     @item_name = variable_name
     @template_name = template_name
@@ -51,20 +51,8 @@ class EachBinding < BaseBinding
     @templates[position].remove
     @templates.delete_at(position)
     
-    value_obj = @value.cur
-    
-    if value_obj
-      size = value_obj.size - 1
-    else
-      size = 0
-    end
-    
-    # puts "Position: #{position} to #{size}"
-    
     # Removed at the position, update context for every item after this position
-    position.upto(size) do |index|
-      @templates[index].context.locals[:index].cur = index
-    end
+    update_indexes_after(position)
   end
 
   def item_added(position)
@@ -73,18 +61,34 @@ class EachBinding < BaseBinding
     binding_name = @@binding_number
     @@binding_number += 1
 
-    # Setup new bindings in the spot we want to insert the item
-    section.insert_anchor_before_end(binding_name)
+    if position >= @templates.size
+      # Setup new bindings in the spot we want to insert the item
+      section.insert_anchor_before_end(binding_name)
+    else
+      # Insert the item before an existing item 
+      section.insert_anchor_before(binding_name, @templates[position].binding_name)
+    end
 
     index = ReactiveValue.new(position)
     value = @value[index]
     
     item_context = SubContext.new({@item_name => value, :index => index, :parent => @value}, @context)
 
-    # ObjectTracker.enable_cache
-    @templates << TemplateRenderer.new(@target, item_context, binding_name, @template_name)
-    # puts "ADDED 2"
-    # ObjectTracker.disable_cache
+    item_template = TemplateRenderer.new(@page, @target, item_context, binding_name, @template_name)
+    @templates.insert(position, item_template)
+    
+    update_indexes_after(position)
+  end
+  
+  # When items are added or removed in the middle of the list, we need
+  # to update each templates index value.
+  def update_indexes_after(start_index)
+    size = @templates.size
+    if size > 0
+      start_index.upto(@templates.size-1) do |index|
+        @templates[index].context.locals[:index].cur = index
+      end
+    end
   end
 
   def update(item=nil)

data/lib/volt/page/bindings/event_binding.rb

@@ -21,10 +21,8 @@ end
 
 class EventBinding < BaseBinding
   attr_accessor :context, :binding_name
-  def initialize(target, context, binding_name, event_name, call_proc)
-    @target = target
-    @context = context
-    @binding_name = binding_name
+  def initialize(page, target, context, binding_name, event_name, call_proc)
+    super(page, target, context, binding_name)
     @event_name = event_name
     
     handler = Proc.new do |js_event|
@@ -36,12 +34,12 @@ class EventBinding < BaseBinding
       result = @context.instance_exec(event, &call_proc)
     end
 
-    @listener = $page.events.add(event_name, self, handler)
+    @listener = @page.events.add(event_name, self, handler)
   end
 
   # Remove the event binding
   def remove
     # puts "REMOVE EL FOR #{@event}"
-    $page.events.remove(@event_name, self)
+    @page.events.remove(@event_name, self)
   end
 end

data/lib/volt/page/bindings/if_binding.rb

@@ -1,12 +1,11 @@
 require 'volt/page/bindings/base_binding'
 
 class IfBinding < BaseBinding
-  def initialize(target, context, binding_name, branches)
-    getter, template_name = branches[0]
+  def initialize(page, target, context, binding_name, branches)
     # puts "New If Binding: #{binding_name}, #{getter.inspect}"
+    super(page, target, context, binding_name)
 
-
-    super(target, context, binding_name)
+    getter, template_name = branches[0]
 
     @branches = []
     @listeners = []
@@ -58,7 +57,7 @@ class IfBinding < BaseBinding
       end
       
       if true_template
-        @template = TemplateRenderer.new(@target, @context, binding_name, true_template)
+        @template = TemplateRenderer.new(@page, @target, @context, binding_name, true_template)
       end
     end
   end

data/lib/volt/page/bindings/template_binding.rb

@@ -2,9 +2,9 @@ require 'volt/page/bindings/base_binding'
 require 'volt/page/template_renderer'
 
 class TemplateBinding < BaseBinding
-  def initialize(target, context, binding_name, binding_in_path, getter)
+  def initialize(page, target, context, binding_name, binding_in_path, getter)
     # puts "New template binding: #{context.inspect} - #{binding_name.inspect}"
-    super(target, context, binding_name)
+    super(page, target, context, binding_name)
     
     # Binding in path is the path for the template this binding is in
     setup_path(binding_in_path)
@@ -40,7 +40,7 @@ class TemplateBinding < BaseBinding
   
   # Returns true if there is a template at the path
   def check_for_template?(path)
-    $page.templates[path]
+    @page.templates[path]
   end
   
   # Takes in a lookup path and returns the full path for the matching
@@ -141,7 +141,7 @@ class TemplateBinding < BaseBinding
       current_context = @context
     end
 
-    @current_template = TemplateRenderer.new(@target, current_context, @binding_name, full_path)   
+    @current_template = TemplateRenderer.new(@page, @target, current_context, @binding_name, full_path)   
     
     call_ready
   end

data/lib/volt/page/channel.rb

@@ -89,7 +89,6 @@ class Channel
   
   def message_received(message)
     message = JSON.parse(message)
-    # puts "GOT: #{message.inspect}"
     trigger!('message', nil, *message)
   end
   

data/lib/volt/page/document.rb

@@ -0,0 +1,7 @@
+# Should have
+# templates
+# events
+
+class Document
+  
+end

data/lib/volt/page/page.rb

@@ -61,7 +61,7 @@ class Page
           }
         });
       
-        $(document).on('click', 'a', function(event) {        
+        $(document).on('click', 'a', function(event) {
           Opal.gvars.page.$link_clicked($(this).attr('href'));
           event.stopPropagation();
         
@@ -141,7 +141,7 @@ class Page
     main_controller = IndexController.new
 
     # Setup main page template
-    TemplateRenderer.new(DomTarget.new, main_controller, 'CONTENT', 'home/index/index/body')
+    TemplateRenderer.new(self, DomTarget.new, main_controller, 'CONTENT', 'home/index/index/body')
 
     # Setup title listener template
     title_target = AttributeTarget.new
@@ -149,7 +149,7 @@ class Page
       title = title_target.to_html
       `document.title = title;`
     end
-    TemplateRenderer.new(title_target, main_controller, "main", "home/index/index/title")
+    TemplateRenderer.new(self, title_target, main_controller, "main", "home/index/index/title")
     
     # TODO: this dom ready should really happen in the template renderer
     main_controller.dom_ready if main_controller.respond_to?(:dom_ready)
@@ -181,7 +181,7 @@ if Volt.client?
   $page = Page.new
 
   # Call start once the page is loaded
-  Document.ready? do
+  Document.ready? do    
     $page.start
   end
 end

data/lib/volt/page/reactive_template.rb

@@ -1,11 +1,11 @@
 class ReactiveTemplate
   include Events
   
-  def initialize(context, template_path)
+  def initialize(page, context, template_path)
     # puts "New Reactive Template: #{context.inspect} - #{template_path.inspect}"
     @template_path = template_path
     @target = AttributeTarget.new
-    @template = TemplateRenderer.new(@target, context, "main", template_path)
+    @template = TemplateRenderer.new(page, @target, context, "main", template_path)
   end
   
   def event_added(event, scope_provider, first)

data/lib/volt/page/targets/dom_section.rb

@@ -47,6 +47,11 @@ class DomSection < BaseSection
     Element.find(@end_node).before("<!-- $#{binding_name} --><!-- $/#{binding_name} -->")
   end
   
+  def insert_anchor_before(binding_name, insert_after_binding)
+    node = find_by_comment("$#{insert_after_binding}")
+    Element.find(node).before("<!-- $#{binding_name} --><!-- $/#{binding_name} -->")
+  end
+  
   # Takes in an array of dom nodes and replaces the current content
   # with the new nodes
   def nodes=(nodes)

data/lib/volt/page/tasks.rb

@@ -29,19 +29,17 @@ class Tasks
   
   def received_message(name, callback_id, *args)
     case name
+    when 'added', 'removed', 'updated', 'changed'
+      notify_query(name, *args)
     when 'response'
       response(callback_id, *args)
-    when 'changed'
-      changed(*args)
-    when 'added'
-      added(*args)
-    when 'removed'
-      removed(*args)
     when 'reload'
       reload
     end
   end
   
+  # When a request is sent to the backend, it can attach a callback,
+  # this is called from the backend to pass to the callback.
   def response(callback_id, result, error)
     callback = @callbacks.delete(callback_id)
     
@@ -55,40 +53,12 @@ class Tasks
     end
   end
   
-  def changed(model_id, data)
-    $loading_models = true
-    puts "From Backend: UPDATE: #{model_id} with #{data.inspect}"
-    Persistors::ModelStore.update(model_id, data)
-    $loading_models = false
-  end
-  
-  def added(path, data)
-    $loading_models = true
-    
-    # Don't add if already in there
-    # TODO: shouldn't send twice
-    unless Persistors::ModelStore.from_id(data[:_id])
-    
-      _, parent_id = data.find {|k,v| k != :_id && k[-3..-1] == '_id'}
-      if parent_id
-        parent_collection = Persistors::ModelStore.from_id(parent_id).model
-      else
-        # On the root
-        parent_collection = $page.store
-      end
-    
-      puts "From Backend: Add: #{path.inspect} - #{data.inspect}"
-      parent_collection.send(path) << data
-    end
-    $loading_models = false
-  end
-  
-  def removed(id)
-    puts "From Backend: Remove: #{id}"
-    $loading_models = true
-    model = Persistors::ModelStore.from_id(id)
-    model.delete!
-    $loading_models = false
+  # Called when the backend sends a notification to change the results of
+  # a query.
+  def notify_query(method_name, collection, query, *args)
+    query_obj = Persistors::ArrayStore.query_pool.lookup(collection, query)
+    puts "FOUND QUERY: #{collection.inspect} - #{query.inspect} - #{query_obj.inspect} - #{method_name} - #{query_obj.instance_variable_get('@stores').inspect}"
+    query_obj.send(method_name, *args)
   end
   
   def reload