volt 0.7.23 → 0.8.0

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

@@ -2,24 +2,23 @@ require 'volt/page/bindings/base_binding'
 
 class ContentBinding < BaseBinding
   def initialize(page, target, context, binding_name, getter)
+    # puts "New Content Binding: #{self.inspect}"
     super(page, target, context, binding_name)
 
-    # Find the source for the content binding
-    @value = value_from_getter(getter)
-
-    # Run the initial render
-    update
-
-    if @value.reactive?
-      @changed_listener = @value.on('changed') { update }
-    end
+    # Listen for changes
+    @computation = -> do
+      begin
+        update(@context.instance_eval(&getter))
+      rescue => e
+        Volt.logger.error("ContentBinding Error: #{e.inspect}")
+        update('')
+      end
+    end.watch!
   end
 
-  def update
-    value = @value.cur.or('')
-    if value.reactive?
-      puts "GOT CUR: #{value.inspect}"
-    end
+  def update(value)
+    # TODORW:
+    value = value.nil? ? '' : value
 
     # Exception values display the exception as a string
     value = value.to_s
@@ -30,10 +29,8 @@ class ContentBinding < BaseBinding
   end
 
   def remove
-    if @changed_listener
-      @changed_listener.remove
-      @changed_listener = nil
-    end
+    @computation.stop if @computation
+    @computation = nil
 
     super
   end

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

@@ -7,40 +7,57 @@ class EachBinding < BaseBinding
     @item_name = variable_name
     @template_name = template_name
 
-    # Find the source for the content binding
-    @value = value_from_getter(getter)
-
     @templates = []
 
-    # Run the initial render
-    # update
-    reload
+    @getter = getter
 
-    @added_listener = @value.on('added') { |_, position, item| item_added(position) }
-    @changed_listener = @value.on('changed') { reload }
-    @removed_listener = @value.on('removed') { |_, position| item_removed(position) }
+    # Listen for changes
+    @computation = -> { reload }.watch!
   end
 
   # When a changed event happens, we update to the new size.
   def reload
-    # Adjust to the new size
-    values = current_values
-    templates_size = @templates.size
-    values_size = values.size
+    begin
+      value = @context.instance_eval(&@getter)
+    rescue => e
+      Volt.logger.error("EachBinding Error: #{e.inspect}")
+      value = []
+    end
 
-    if templates_size < values_size
-      (templates_size).upto(values_size-1) do |index|
-        item_added(index)
+    # Since we're checking things like size, we don't want this to be re-triggered on a
+    # size change, so we run without tracking.
+    Computation.run_without_tracking do
+      # puts "RELOAD:-------------- #{value.inspect}"
+      # Adjust to the new size
+      values = current_values(value)
+      @value = values
+
+      @added_listener.remove if @added_listener
+      @removed_listener.remove if @removed_listener
+
+      if @value.respond_to?(:on)
+        @added_listener = @value.on('added') { |position| item_added(position) }
+        @removed_listener = @value.on('removed') { |position| item_removed(position) }
       end
-    elsif templates_size > values_size
-      (templates_size-1).downto(values_size) do |index|
+
+      templates_size = @templates.size
+      values_size = values.size
+
+      # Start over, re-create all nodes
+      (templates_size-1).downto(0) do |index|
         item_removed(index)
       end
+      0.upto(values_size-1) do |index|
+        item_added(index)
+      end
     end
   end
 
   def item_removed(position)
-    position = position.cur
+    # Remove dependency
+    @templates[position].context.locals[:index_dependency].remove
+
+    # puts "REMOVE AT: #{position.inspect} - #{@templates[position].inspect} - #{@templates.inspect}"
     @templates[position].remove_anchors
     @templates[position].remove
     @templates.delete_at(position)
@@ -50,7 +67,6 @@ class EachBinding < BaseBinding
   end
 
   def item_added(position)
-    # ObjectTracker.enable_cache
     binding_name = @@binding_number
     @@binding_number += 1
 
@@ -62,15 +78,28 @@ class EachBinding < BaseBinding
       dom_section.insert_anchor_before(binding_name, @templates[position].binding_name)
     end
 
-    index = ReactiveValue.new(position)
-    value = @value[index]
+    # TODORW: :parent => @value may change
+    item_context = SubContext.new({:_index_value => position, :parent => @value}, @context)
+    item_context.locals[@item_name.to_sym] = Proc.new { @value[item_context.locals[:_index_value]] }
 
-    item_context = SubContext.new({@item_name => value, :index => index, :parent => @value}, @context)
+    position_dependency = Dependency.new
+    item_context.locals[:index_dependency] = position_dependency
+
+    # Get and set index
+    item_context.locals[:index=] = Proc.new do |val|
+      position_dependency.changed!
+      item_context.locals[:_index_value] = val
+    end
+
+    item_context.locals[:index] = Proc.new do
+      position_dependency.depend
+      item_context.locals[:_index_value]
+    end
 
     item_template = TemplateRenderer.new(@page, @target, item_context, binding_name, @template_name)
     @templates.insert(position, item_template)
 
-    # update_indexes_after(position)
+    update_indexes_after(position)
   end
 
   # When items are added or removed in the middle of the list, we need
@@ -78,18 +107,15 @@ class EachBinding < BaseBinding
   def update_indexes_after(start_index)
     size = @templates.size
     if size > 0
-      puts @templates.inspect
       start_index.upto(size-1) do |index|
-        @templates[index].context.locals[:index].cur = index
+        @templates[index].context.locals[:index=].call(index)
       end
     end
   end
 
-  def current_values
-    values = @value.cur
-
+  def current_values(values)
     return [] if values.is_a?(Model) || values.is_a?(Exception)
-    values = values.attributes unless values.is_a?(ReactiveArray)
+    values = values.attributes if values.respond_to?(:attributes)
 
     return values
   end
@@ -97,17 +123,24 @@ class EachBinding < BaseBinding
 
   # When this each_binding is removed, cleanup.
   def remove
+    @computation.stop
+    @computation = nil
+
+    # Clear value
+    @value = nil
+
     @added_listener.remove
     @added_listener = nil
 
-    @changed_listener.remove
-    @changed_listener = nil
-
     @removed_listener.remove
     @removed_listener = nil
 
     if @templates
-      @templates.compact.each(&:remove)
+      template_count = @templates.size
+      template_count.times do |index|
+        item_removed(template_count - index - 1)
+      end
+      # @templates.compact.each(&:remove)
       @templates = nil
     end
 

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

@@ -13,13 +13,7 @@ class IfBinding < BaseBinding
       getter, template_name = branch
 
       if getter.present?
-        # Lookup the value
-        value = value_from_getter(getter)
-
-        if value.reactive?
-          # Trigger change when value changes
-          @listeners << value.on('changed') { update }
-        end
+        value = getter
       else
         # A nil value means this is an unconditional else branch, it
         # should always be true
@@ -29,7 +23,7 @@ class IfBinding < BaseBinding
       @branches << [value, template_name]
     end
 
-    update
+    @computation = -> { update }.watch!
   end
 
   def update
@@ -38,10 +32,19 @@ class IfBinding < BaseBinding
     @branches.each do |branch|
       value, template_name = branch
 
-      current_value = value.cur
+      if value.is_a?(Proc)
+        begin
+          current_value = @context.instance_eval(&value)
+        rescue => e
+          Volt.logger.error("IfBinding:#{object_id} error: #{e.inspect}\n" + `value.toString()`)
+          current_value = false
+        end
+      else
+        current_value = value
+      end
 
       # TODO: A bug in opal requires us to check == true
-      if current_value.true? == true && !current_value.is_a?(Exception)
+      if current_value && !current_value.nil? && !current_value.is_a?(Exception)
         # This branch is currently true
         true_template = template_name
         break
@@ -64,8 +67,8 @@ class IfBinding < BaseBinding
   end
 
   def remove
-    # Remove all listeners on any reactive values
-    @listeners.each(&:remove)
+    @computation.stop if @computation
+    @computation = nil
 
     @template.remove if @template
 

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

@@ -11,28 +11,10 @@ class TemplateBinding < BaseBinding
 
     @current_template = nil
 
-    # Find the source for the getter binding
-    @path, section, @options = value_from_getter(getter)
-
-    if section.is_a?(String)
-      # Render this as a section
-      @section = section
-    else
-      # Use the value passed in as the default arguments
-      @arguments = section
-    end
-
-    # Sometimes we want multiple template bindings to share the same controller (usually
-    # when displaying a :Title and a :Body), this instance tracks those.
-    if @options && (controller_group = @options[:controller_group])
-      @grouped_controller = GroupedControllers.new(controller_group)
-    end
+    @getter = getter
 
     # Run the initial render
-    update
-
-    @path_changed_listener = @path.on('changed') { queue_update } if @path.reactive?
-    @section_changed_listener = @section.on('changed') { queue_update } if @section && @section.reactive?
+    @computation = -> { update(*@context.instance_eval(&getter)) }.watch!
   end
 
   def setup_path(binding_in_path)
@@ -112,43 +94,88 @@ class TemplateBinding < BaseBinding
     return nil, nil
   end
 
-  # Called when the path changes.  If we are sharing a controller, clear the cached
-  # controller before we queue
-  def queue_update
-    @grouped_controller.clear if @grouped_controller
+  def update(path, section_or_arguments=nil, options={})
+    Computation.run_without_tracking do
+      # Remove existing template and call _removed
+      controller_send(:"#{@action}_removed") if @action && @controller
+      @current_template.remove if @current_template
 
-    super
-  end
+      @options = options
 
-  def update
-    full_path, controller_path = path_for_template(@path.cur, @section.cur)
+      # A blank path needs to load a missing template, otherwise it tries to load
+      # the same template.
+      path = path.blank? ? '---missing---' : path
 
-    @current_template.remove if @current_template
+      section = nil
+      @arguments = nil
 
-    if @arguments
-      # Load in any procs
-      @arguments.each_pair do |key,value|
-        if value.class == Proc
-          @arguments[key.gsub('-', '_')] = value.call
-        end
+      if section_or_arguments.is_a?(String)
+        # Render this as a section
+        section = section_or_arguments
+      else
+        # Use the value passed in as the default arguments
+        @arguments = section_or_arguments
+      end
+
+      # Sometimes we want multiple template bindings to share the same controller (usually
+      # when displaying a :Title and a :Body), this instance tracks those.
+      if @options && (controller_group = @options[:controller_group])
+        @grouped_controller = GroupedControllers.new(controller_group)
+      else
+        clear_grouped_controller
       end
+
+      full_path, controller_path = path_for_template(path, section)
+      render_template(full_path, controller_path)
+
+      queue_clear_grouped_controller
+    end
+  end
+
+  # On the next tick, we clear the grouped controller so that any changes to template paths
+  # will create a new controller and trigger the action.
+  def queue_clear_grouped_controller
+    if Volt.in_browser?
+      # In the browser, we want to keep a grouped controller around during a single run
+      # of the event loop.  To make that happen, we clear it on the next tick.
+      `setImmediate(function() {`
+        clear_grouped_controller
+      `})`
+    else
+      # For the backend, clear it immediately
+      clear_grouped_controller
     end
+  end
 
-    render_template(full_path, controller_path)
+  def clear_grouped_controller
+    if @grouped_controller
+      @grouped_controller.clear
+      @grouped_controller = nil
+    end
   end
 
   # The context for templates can be either a controller, or the original context.
   def render_template(full_path, controller_path)
-    args = @arguments ? [@arguments] : []
+    if @arguments
+      args = [SubContext.new(@arguments)]
+    else
+      args = []
+    end
 
     @controller = nil
 
     # Fetch grouped controllers if we're grouping
     @controller = @grouped_controller.get if @grouped_controller
 
-    # Otherwise, make a new controller
-    unless @controller
-      controller_class, action = get_controller(controller_path)
+    # The action to be called and rendered
+    @action = nil
+
+    if @controller
+      # Track that we're using the group controller
+      @grouped_controller.inc if @grouped_controller
+    else
+      # Otherwise, make a new controller
+      controller_class, @action = get_controller(controller_path)
 
       if controller_class
         # Setup the controller
@@ -158,7 +185,7 @@ class TemplateBinding < BaseBinding
       end
 
       # Trigger the action
-      @controller.send(action) if @controller.respond_to?(action)
+      controller_send(@action) if @action
 
       # Track the grouped controller
       @grouped_controller.set(@controller) if @grouped_controller
@@ -177,24 +204,12 @@ class TemplateBinding < BaseBinding
         @controller.section = @current_template.dom_section
       end
 
-      if @controller.respond_to?(:dom_ready)
-        @controller.dom_ready
-      end
+      controller_send(:"#{@action}_ready") if @action
     end
   end
 
   def remove
-    @grouped_controller.clear if @grouped_controller
-
-    if @path_changed_listener
-      @path_changed_listener.remove
-      @path_changed_listener = nil
-    end
-
-    if @section_changed_listener
-      @section_changed_listener.remove
-      @section_changed_listener = nil
-    end
+    clear_grouped_controller
 
     if @current_template
       # Remove the template if one has been rendered, when the template binding is
@@ -205,16 +220,19 @@ class TemplateBinding < BaseBinding
     super
 
     if @controller
-      # Let the controller know we removed
-      if @controller.respond_to?(:dom_removed)
-        @controller.dom_removed
-      end
+      controller_send(:"#{@action}_removed") if @action
 
       @controller = nil
     end
   end
 
   private
+    # Sends the action to the controller if it exists
+    def controller_send(action_name)
+      if @controller.respond_to?(action_name)
+        @controller.send(action_name)
+      end
+    end
 
     # Fetch the controller class
     def get_controller(controller_path)