volt 0.7.1 → 0.7.2

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

@@ -1,19 +1,14 @@
 require 'volt/page/targets/base_section'
+require 'volt/page/targets/helpers/comment_searchers'
 
 class DomSection < BaseSection
+  include CommentSearchers
+
   def initialize(binding_name)
     @start_node = find_by_comment("$#{binding_name}")
     @end_node = find_by_comment("$/#{binding_name}")
   end
 
-  def find_by_comment(text, in_node=`document`)
-    node = nil
-
-    %x{
-      node = document.evaluate("//comment()[. = ' " + text + " ']", in_node, null, XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null).iterateNext();
-    }
-    return node
-  end
 
   def text=(value)
     %x{
@@ -23,7 +18,9 @@ class DomSection < BaseSection
   end
 
   def html=(value)
-    set_content_and_rezero_bindings(value, {})
+    new_nodes = build_from_html(value)
+
+    self.nodes = `new_nodes.childNodes`
   end
 
   def remove
@@ -48,6 +45,7 @@ class DomSection < BaseSection
   end
 
   def insert_anchor_before(binding_name, insert_after_binding)
+    puts "insert_anchor_before"
     node = find_by_comment("$#{insert_after_binding}")
     Element.find(node).before("<!-- $#{binding_name} --><!-- $/#{binding_name} -->")
   end
@@ -75,75 +73,22 @@ class DomSection < BaseSection
     return `range.commonAncestorContainer`
   end
 
-  # Takes in our html and bindings, and rezero's the comment names, and the
-  # bindings.  Returns an updated bindings hash
-  def set_content_and_rezero_bindings(html, bindings)
-    sub_nodes = nil
-    temp_div = nil
-
-    %x{
-      temp_div = document.createElement('div');
-      var doc = jQuery.parseHTML(html);
-
-      if (doc) {
-        for (var i=0;i < doc.length;i++) {
-          temp_div.appendChild(doc[i]);
-        }
-      }
-    }
-
-    new_bindings = {}
-    # Loop through the bindings, and rezero.
-    bindings.each_pair do |name,binding|
-      new_name = @@binding_number
-
-      if name.cur.is_a?(String)
-        if name[0..1] == 'id'
-        # Find by id
-          %x{
-            var node = temp_div.querySelector('#' + name);
-            node.setAttribute('id', 'id' +new_name);
-          }
-
-          new_bindings["id#{new_name}"] = binding
-        else
-          # Assume a fixed id
-          # TODO: We should raise an exception if this id is already on the page
-          new_bindings[name] = binding
-        end
-      else
-        # puts "----- #{name.inspect} - #{new_name}"
-        # `console.log(temp_div);`
-        # Change the comment ids
-        start_comment = find_by_comment("$#{name}", temp_div)
-        end_comment = find_by_comment("$/#{name}", temp_div)
-
-        %x{
-          start_comment.textContent = " $" + new_name + " ";
-          end_comment.textContent = " $/" + new_name + " ";
-        }
-
-        new_bindings[new_name] = binding
-      end
-
-
-      @@binding_number += 1
-    end
-
+  def set_template(dom_template)
+    dom_nodes, bindings = dom_template.make_new
 
     children = nil
     %x{
-      children = temp_div.childNodes;
+      children = dom_nodes.childNodes;
     }
 
     # Update the nodes
     self.nodes = children
 
     %x{
-      temp_div = null;
+      dom_nodes = null;
     }
 
-    return new_bindings
+    return bindings
   end
 
   def range
@@ -161,4 +106,8 @@ class DomSection < BaseSection
     return range
   end
 
+  def inspect
+    "<#{self.class.to_s}>"
+  end
+
 end

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

@@ -0,0 +1,99 @@
+require 'volt/page/targets/helpers/comment_searchers'
+
+# A dom template is used to optimize going from a template name to
+# dom nodes and bindings.  It stores a copy of the template's parsed
+# dom nodes, then when a new instance is requested, it updates the
+# dom markers (comments) for new binding numbers and returns a cloneNode'd
+# version of the dom nodes and the bindings.
+class DomTemplate
+  include CommentSearchers
+
+  def initialize(page, template_name)
+    template = page.templates[template_name]
+
+    if template
+      html = template['html']
+      @bindings = template['bindings']
+    else
+      html = "<div>-- &lt; missing template #{template_name.inspect.gsub('<', '&lt;').gsub('>', '&gt;')} &gt; --</div>"
+      @bindings = {}
+    end
+
+    @nodes = build_from_html(html)
+
+    track_binding_anchors
+  end
+
+  # Returns the dom nodes and bindings
+  def make_new
+    bindings = update_binding_anchors!
+
+    new_nodes = `self.nodes.cloneNode(true)`
+
+    return [new_nodes, bindings]
+  end
+
+
+  # Finds each of the binding anchors in the temp dom, then stores a reference
+  # to them so they can be quickly updated without using xpath to find them again.
+  def track_binding_anchors
+    @binding_anchors = {}
+
+    # Loop through the bindings, find in nodes.
+    @bindings.each_pair do |name,binding|
+      if name.is_a?(String)
+        # Find the dom node for an attribute anchor
+        node = nil
+        %x{
+          node = self.nodes.querySelector('#' + name);
+        }
+        @binding_anchors[name] = node
+      else
+        # Find the dom node for a comment anchor
+        start_comment = find_by_comment("$#{name}", @nodes)
+        end_comment = find_by_comment("$/#{name}", @nodes)
+
+        @binding_anchors[name] = [start_comment, end_comment]
+      end
+    end
+  end
+
+  # Takes the binding_anchors and updates them with new numbers (comments and id's)
+  # then returns the bindings updated to the new numbers.
+  def update_binding_anchors!
+    new_bindings = {}
+
+    @binding_anchors.each_pair do |name, anchors|
+      new_name = @@binding_number
+      @@binding_number += 1
+
+      if name.is_a?(String)
+        if name[0..1] == 'id'
+          # A generated id
+          # update the id
+          `anchors.setAttribute('id', 'id' + new_name);`
+
+          new_bindings["id#{new_name}"] = @bindings[name]
+        else
+          # Assume a fixed id, should not be updated
+          # TODO: Might want to check the page to see if a node
+          # with this id already exists and raise if it does.
+
+          # Copy from existing binding
+          new_bindings[name] = @bindings[name]
+        end
+      else
+        start_comment, end_comment = anchors
+
+        %x{
+          start_comment.textContent = " $" + new_name + " ";
+          end_comment.textContent = " $/" + new_name + " ";
+        }
+
+        new_bindings[new_name] = @bindings[name]
+      end
+    end
+
+    return new_bindings
+  end
+end

data/lib/volt/page/targets/helpers/comment_searchers.rb

@@ -0,0 +1,29 @@
+module CommentSearchers
+
+  def find_by_comment(text, in_node=`document`)
+    node = nil
+
+    %x{
+      node = document.evaluate("//comment()[. = ' " + text + " ']", in_node, null, XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null).iterateNext();
+    }
+    return node
+  end
+
+
+  # Returns an unattached div with the nodes from the passed
+  # in html.
+  def build_from_html(html)
+    temp_div = nil
+    %x{
+      temp_div = document.createElement('div');
+      var doc = jQuery.parseHTML(html);
+
+      if (doc) {
+        for (var i=0;i < doc.length;i++) {
+          temp_div.appendChild(doc[i]);
+        }
+      }
+    }
+    return temp_div
+  end
+end

data/lib/volt/page/template_renderer.rb

@@ -7,18 +7,10 @@ class TemplateRenderer < BaseBinding
     super(page, target, context, binding_name)
 
     # puts "Template Name: #{template_name}"
-    @template = @page.templates[template_name]
-    @sub_bindings = []
 
-    if @template
-      html = @template['html']
-      bindings = @template['bindings']
-    else
-      html = "<div>-- &lt; missing template #{template_name.inspect.gsub('<', '&lt;').gsub('>', '&gt;')} &gt; --</div>"
-      bindings = {}
-    end
+    @sub_bindings = []
 
-    bindings = self.section.set_content_and_rezero_bindings(html, bindings)
+    bindings = self.section.set_content_to_template(page, template_name)
 
     bindings.each_pair do |id,bindings_for_id|
       bindings_for_id.each do |binding|
@@ -43,8 +35,4 @@ class TemplateRenderer < BaseBinding
 
     super
   end
-
-  def remove_anchors
-    section.remove_anchors
-  end
 end

data/lib/volt/reactive/array_extensions.rb

@@ -1,5 +1,4 @@
 class Array
-  include ReactiveTags
   alias :__old_plus :+
 
   def +(val)

data/lib/volt/reactive/event_chain.rb

@@ -16,7 +16,12 @@ class ChainListener
   end
 
   def remove
-    raise "event chain already removed" if @removed
+    # raise "event chain already removed" if @removed
+    if @removed
+      puts "event chain already removed"
+      return
+    end
+
     @removed = true
     @event_chain.remove_object(self)
 
@@ -27,6 +32,7 @@ class ChainListener
 
     if RUBY_PLATFORM == 'opal' && CHAIN_DEBUG
       `window.chain_listeners -= 1;`
+      `console.log('del chain listeners: ', window.chain_listeners)`
     end
   end
 end
@@ -81,7 +87,8 @@ class EventChain
   def remove_object(chain_listener)
     @event_chain[chain_listener].each_pair do |event,listener|
       # Unbind each listener
-      listener.remove
+      # TODO: The if shouldn't be needed, but sometimes we get nil for some reason?
+      listener.remove if listener
     end
 
     @event_chain.delete(chain_listener)

data/lib/volt/reactive/events.rb

@@ -1,5 +1,4 @@
 require 'volt/reactive/event_chain'
-require 'volt/reactive/object_tracker'
 
 DEBUG = false
 
@@ -47,18 +46,15 @@ class Listener
   end
 
   def call(*args)
-    # raise "Triggered on removed: #{@event} on #{@klass2.inspect}" if @removed
     if @removed
-      puts "Triggered on a removed event: #{@event}"
+      # puts "Triggered on a removed event: #{@event}"
       return
     end
 
-    # Queue a live value update
     if @klass.reactive?
-      # We are working with a reactive value.  Its receiving an event meaning
-      # something changed.  Queue an update of the value it tracks.
-      @klass.object_tracker.queue_update
-      # puts "Queued: #{ObjectTracker.queue.inspect}"
+      # Update the reactive value's current value to let it know it is being
+      # followed.
+      @klass.update_followers if @klass.respond_to?(:update_followers)
     end
 
     @callback.call(*args)
@@ -67,7 +63,11 @@ class Listener
   # Removes the listener from where ever it was created.
   def remove
     # puts "FAIL:" if @removed
-    raise "event #{@event} already removed" if @removed
+    if @removed
+      # raise "event #{@event} already removed"
+      puts "event #{@event} already removed"
+      return
+    end
 
     # puts "e rem: #{@event} on #{@klass.inspect}"
     if DEBUG && RUBY_PLATFORM == 'opal'
@@ -101,33 +101,29 @@ module Events
   # Add a listener for an event
   def on(event, scope_provider=nil, &block)
 
-
-    # if reactive? && [:added, :removed].include?(event)
-    #   self.object_tracker.queue_update
-    #   ObjectTracker.process_queue
-    # end
-
-
     # puts "Register: #{event} on #{self.inspect}"
     event = event.to_sym
 
+    @has_listeners = true
+
     new_listener = Listener.new(self, event, scope_provider, block)
 
     @listeners ||= {}
     @listeners[event] ||= []
     @listeners[event] << new_listener
 
-    first = @listeners[event].size == 1
+    first_for_event = @listeners[event].size == 1
+    first = first_for_event && @listeners.size == 1
 
     # When events get added, we need to notify event chains so they
     # can update and chain any new events.
-    event_chain.add_event(event) if first
+    event_chain.add_event(event) if first_for_event
 
     # Let the included class know that an event was registered. (if it cares)
     if self.respond_to?(:event_added)
       # call event added passing the event, the scope, and a boolean if it
       # is the first time this event has been added.
-      self.event_added(event, scope_provider, first)
+      self.event_added(event, scope_provider, first, first_for_event)
     end
 
     return new_listener
@@ -141,6 +137,10 @@ module Events
     @listeners || {}
   end
 
+  def has_listeners?
+    @has_listeners
+  end
+
   # Typically you would call .remove on the listener returned from the .on
   # method.  However, here you can also pass in the original proc to remove
   # a listener
@@ -149,31 +149,38 @@ module Events
 
     raise "Unable to delete #{event} from #{self.inspect}" unless @listeners && @listeners[event]
 
-    # if @listeners && @listeners[event]
-      @listeners[event].delete(listener)
+    @listeners[event].delete(listener)
 
-      no_more_events = @listeners[event].size == 0
-      if no_more_events
-        # When events are removed, we need to notify any relevent chains so they
-        # can remove any chained events.
-        event_chain.remove_event(event)
+    last_for_event = @listeners[event].size == 0
 
-        # No registered listeners now on this event
-        @listeners.delete(event)
-      end
+    if last_for_event
+      # When events are removed, we need to notify any relevent chains so they
+      # can remove any chained events.
+      event_chain.remove_event(event)
 
-      # Let the class we're included on know that we removed a listener (if it cares)
-      if self.respond_to?(:event_removed)
-        # Pass in the event and a boolean indicating if it is the last event
-        self.event_removed(event, no_more_events)
-      end
-    # end
+      # No registered listeners now on this event
+      @listeners.delete(event)
+    end
+
+    last = last_for_event && @listeners.size == 0
+
+    # Let the class we're included on know that we removed a listener (if it cares)
+    if self.respond_to?(:event_removed)
+      # Pass in the event and a boolean indicating if it is the last event
+      self.event_removed(event, last, last_for_event)
+    end
+
+    if last
+      @has_listeners = nil
+    end
   end
 
   def trigger!(event, filter=nil, *args)
     are_reactive = reactive?
-    # puts "TRIGGER FOR: #{event} on #{self.inspect}" if !reactive?
-    ObjectTracker.process_queue if !are_reactive# && !respond_to?(:skip_current_queue_flush)
+    # ObjectTracker.process_queue if !are_reactive
+    # puts "DT"
+    # insp = self.inspect
+    # puts "TRIGGER #{event} on #{insp}"
 
     event = event.to_sym
 

data/lib/volt/reactive/object_tracking.rb

@@ -4,7 +4,7 @@ module ObjectTracking
     if value.reactive?
       # TODO: We should build this in so it fires just for the current index.
       # Currently this is a big performance hit.
-      chain_listener = event_chain.add_object(value.reactive_manager) do |event, *args|
+      chain_listener = event_chain.add_object(value.reactive_manager) do |event, filter, *args|
         yield(event, key, args)
       end
       @reactive_element_listeners ||= {}

data/lib/volt/reactive/reactive_array.rb

@@ -1,4 +1,5 @@
 require 'volt/reactive/object_tracking'
+require 'volt/reactive/reactive_count'
 
 class ReactiveArray# < Array
   include ReactiveTags
@@ -32,6 +33,12 @@ class ReactiveArray# < Array
   # alias :__old_assign :[]=
   def []=(index, value)
     index_val = index.cur
+
+    if index_val < 0
+      # Handle a negative index
+      index_val = size + index_val
+    end
+
     # Clean old value
     __clear_element(index)
 
@@ -233,6 +240,17 @@ class ReactiveArray# < Array
     "#<#{self.class.to_s} #{@array.inspect}>"
   end
 
+  # tag_method(:count) do
+  #   destructive!
+  # end
+  def count(&block)
+    if block
+      return ReactiveCount.new(self, block)
+    else
+      @array.count
+    end
+  end
+
   private
 
     def __clear_element(index)

data/lib/volt/reactive/reactive_count.rb

@@ -0,0 +1,108 @@
+class ReactiveCount
+  include ReactiveTags
+
+  def reactive?
+    true
+  end
+
+  def initialize(source, block)
+    @source = ReactiveValue.new(source)
+    @block = block
+  end
+
+  def cur
+    direct_count
+  end
+
+  # After events are bound, we keep a cache of each cell's count
+  # value, and base the results
+  def cached_count
+
+  end
+
+  # Before events are bound, when .cur is called, we simply
+  # run the count on the source object.
+  def direct_count
+    count = 0
+    @source.size.cur.times do |index|
+      val = @source[index]
+      result = @block.call(val).cur
+      if result == true
+        count += 1
+      end
+    end
+
+    count
+  end
+
+  def setup_listeners
+    puts "SETUP LISTENERS"
+    @cell_trackers = []
+    @added_tracker = @source.on('added') do |_, index|
+      change_cell_count(@source.size.cur)
+      trigger!('changed')
+    end
+
+    @removed_tracker = @source.on('removed') do |_, index|
+      change_cell_count(@source.size.cur)
+      trigger!('changed')
+    end
+
+    # Initial cell tracking
+    change_cell_count(@source.size.cur)
+  end
+
+  # We need to make sure we're listening on the result from each cell,
+  # that way we can trigger when the value changes.
+  def change_cell_count(size)
+    current_size = @cell_trackers.size
+
+    if current_size < size
+      # Add trackers
+
+      current_size.upto(size-1) do |index|
+        # Get the reactive value for the index
+        val = @source[index]
+
+        result = @block.call(val)
+        # puts "TRACK AT #{index} on #{result.inspect}"
+
+        @cell_trackers << result.on('changed') do
+          trigger!('changed')
+        end
+      end
+    elsif current_size > size
+      (current_size-1).downto(size) do |index|
+        # puts "Remove at: #{index}"
+        @cell_trackers[index].remove
+        @cell_trackers.delete_at(index)
+      end
+    end
+  end
+
+
+  def teardown_listeners
+    @added_tracker.remove
+    @added_tracker = nil
+
+    @removed_tracker.remove
+    @removed_tracker = nil
+
+    change_cell_count(0)
+
+    @cell_trackers = nil
+    puts "TEARDOWN"
+  end
+
+  def event_added(event, scope_provider, first, first_for_event)
+    setup_listeners if first
+  end
+
+  def event_removed(event, last, last_for_event)
+    teardown_listeners if last
+  end
+
+  def inspect
+    "@#{cur}"
+  end
+end

data/lib/volt/reactive/reactive_generator.rb

@@ -0,0 +1,44 @@
+class ReactiveGenerator
+  # Takes a hash and returns a ReactiveValue that depends on
+  # any ReactiveValue's inside of the hash (or children).
+  def self.from_hash(hash, skip_if_no_reactives=false)
+    reactives = find_reactives(hash)
+
+    if skip_if_no_reactives && reactives.size == 0
+      # There weren't any reactives, we can just use the hash
+      return hash
+    else
+      # Create a new reactive value that listens on all of its
+      # child reactive values.
+      value = ReactiveValue.new(hash)
+
+      reactives.each do |child|
+        value.reactive_manager.add_parent!(child)
+      end
+
+      return value
+    end
+  end
+
+  # Recursively loop through the data, returning a list of all
+  # reactive values in the hash, array, etc..
+  def self.find_reactives(object)
+    found = []
+    if object.reactive?
+      found << object
+
+      found += find_reactives(object.cur)
+    elsif object.is_a?(Array)
+      object.each do |item|
+        found += find_reactives(item)
+      end
+    elsif object.is_a?(Hash)
+      object.each_pair do |key, value|
+        found += find_reactives(key)
+        found += find_reactives(value)
+      end
+    end
+
+    return found.flatten
+  end
+end