volt 0.2.3

data/lib/volt/templates/targets/binding_document/html_node.rb

@@ -0,0 +1,11 @@
+require 'volt/templates/targets/binding_document/base_node'
+
+class HtmlNode < BaseNode
+  def initialize(html)
+    @html = html
+  end
+  
+  def to_html
+    @html
+  end
+end

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

@@ -0,0 +1,147 @@
+require 'volt/templates/targets/base_section'
+
+class DomSection < BaseSection
+  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{
+      this.$range().deleteContents();
+      this.$range().insertNode(document.createTextNode(#{value}));
+    }
+  end
+
+  def remove
+    range = self.range()
+
+    %x{
+      range.deleteContents();
+    }
+  end
+  
+  def remove_anchors    
+    %x{
+      this.start_node.parentNode.removeChild(this.start_node);
+      this.end_node.parentNode.removeChild(this.end_node);
+    }
+    @start_node = nil
+    @end_node = nil
+  end
+  
+  def insert_anchor_before_end(binding_name)
+    Element.find(@end_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)
+    range = self.range()
+
+    %x{
+      range.deleteContents();
+
+      for (var i=nodes.length-1; i >= 0; i--) {
+        var node = nodes[i];
+
+        node.parentNode.removeChild(node);
+        range.insertNode(node);
+      }
+    }
+  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);
+  
+      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
+        # 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
+
+
+    children = nil
+		%x{
+		  children = temp_div.childNodes;
+		}
+    
+    # Update the nodes
+    self.nodes = children
+    
+    %x{
+      temp_div = null;
+    }
+
+		return new_bindings
+	end
+  
+  private
+  
+    def range
+      return @range if @range
+
+  		range = nil
+  		%x{
+  		  range = document.createRange();
+  		  range.setStartAfter(this.start_node);
+  		  range.setEndBefore(this.end_node);
+  		}
+
+      @range = range
+
+  		return range
+    end
+
+end

data/lib/volt/templates/targets/dom_target.rb

@@ -0,0 +1,11 @@
+require 'volt/templates/targets/base_section'
+require 'volt/templates/targets/dom_section'
+
+# DomTarget's provide an interface that can render bindings into
+# the dom.  Currently only one "dom" is supported, but multiple
+# may be allowed in the future (iframes?) 
+class DomTarget < BaseSection
+  def section(*args)
+    return DomSection.new(*args)
+  end
+end

data/lib/volt/templates/template_binding.rb

@@ -0,0 +1,159 @@
+require 'volt/templates/base_binding'
+require 'volt/templates/template_renderer'
+
+class TemplateBinding < BaseBinding
+  def initialize(target, context, binding_name, binding_in_path, getter)
+    # puts "New template binding: #{context.inspect} - #{binding_name.inspect} - #{getter.inspect}"
+    super(target, context, binding_name)
+    
+    # Binding in path is the path for the template this binding is in
+    setup_path(binding_in_path)
+
+    @current_template = nil
+    
+    # puts "GETTER: #{value_from_getter(getter).inspect}"
+
+    # Find the source for the getter binding
+    @path, section = 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 model
+      @model = section
+    end
+
+    # Run the initial render
+    update
+
+    @path_changed_listener = @path.on('changed') { update } if @path.reactive?
+    @section_changed_listener = @section.on('changed') { update } if @section && @section.reactive?
+  end
+  
+  def setup_path(binding_in_path)
+    path_parts = binding_in_path.split('/')
+    @collection_name = path_parts[0]
+    @controller_name = path_parts[1]
+    @page_name = path_parts[2]
+  end
+  
+  # Returns true if there is a template at the path
+  def check_for_template?(path)
+    $page.templates[path]
+  end
+  
+  # Takes in a lookup path and returns the full path for the matching
+  # template.  Also returns the controller name if applicable.
+  #
+  # Looking up a path is fairly simple.  There are 4 parts needed to find
+  # the html to be rendered.  File paths look like this:
+  # app/{component}/views/{controller_name}/{view}.html
+  # Within the html file may be one or more sections.
+  # 1. component (app/{comp})
+  # 2. controller
+  # 3. view
+  # 4. sections
+  #
+  # When searching for a file, the lookup starts at the section, and moves up.
+  # when moving up, default values are provided for the section, then view/section, etc..
+  # until a file is either found or the component level is reached.
+  #
+  # The defaults are as follows:
+  # 1. component - home
+  # 2. controller - index
+  # 3. view - index
+  # 4. section - body
+  def path_for_template(lookup_path, force_section=nil)
+    parts = lookup_path.split('/')
+    parts_size = parts.size
+
+    default_parts = ['home', 'index', 'index', 'body']
+
+    # When forcing a sub template, we can default the sub template section
+    default_parts[-1] = force_section if force_section
+    
+    (5 - parts_size).times do |path_position|
+      # If they passed in a force_section, we can skip the first
+      next if force_section && path_position == 0
+      
+      full_path = [@collection_name, @controller_name, @page_name, nil]
+
+      offset = 0
+      start_at = full_path.size - parts_size - path_position
+    
+      full_path.size.times do |index|
+        if index >= start_at
+          if part = parts[index-start_at]
+            full_path[index] = part
+          else
+            full_path[index] = default_parts[index]
+          end
+        end
+      end
+
+      path = full_path.join('/')
+      if check_for_template?(path)
+        controller = nil
+        if path_position > 1
+          # Lookup the controller
+          controller = full_path[1]
+        end
+        return path, controller
+      end
+    end
+    
+    return nil
+  end
+
+  def update
+    full_path, controller = path_for_template(@path.cur, @section.cur)
+
+    @current_template.remove if @current_template
+    
+    current_context = @context
+    
+    if @model
+      # Load in any procs
+      @model.each_pair do |key,value|
+        if value.class == Proc
+          @model[key] = value.call
+        end
+      end
+    end
+    
+    # TODO: at the moment a :body section and a :title will both initialize different
+    # controllers.  Maybe we should have a way to tie them together?
+    if controller
+      args = []
+      args << SubContext.new(@model) if @model
+      # Initialize the new controller
+      current_context = Object.send(:const_get, (controller.camelize + 'Controller').to_sym).new(*args)
+    elsif @model
+      # Passed in attributes, but there is no controller
+      current_context = SubContext.new(@model, current_context)      
+    end
+
+    @current_template = TemplateRenderer.new(@target, current_context, @binding_name, full_path)
+  end
+
+  def remove
+    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
+    
+    if @current_template
+      # Remove the template if one has been rendered, when the template binding is
+      # removed.
+      @current_template.remove
+    end
+
+    super
+  end
+end

data/lib/volt/templates/template_renderer.rb

@@ -0,0 +1,50 @@
+require 'volt/templates/base_binding'
+
+class TemplateRenderer < BaseBinding
+  attr_reader :context
+  def initialize(target, context, binding_name, template_name)
+    # puts "new template renderer: #{context.inspect} - #{binding_name.inspect}"
+    super(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
+
+    bindings = self.section.set_content_and_rezero_bindings(html, bindings)
+
+    bindings.each_pair do |id,bindings_for_id|
+      bindings_for_id.each do |binding|
+        @sub_bindings << binding.call(target, context, id)
+      end
+    end
+
+  end
+
+  def remove
+    # puts "Remove Template: #{self} - #{@sub_bindings.inspect}"
+
+    # Remove all of the sub-bindings
+    # @sub_bindings.each(&:remove)
+    
+    @sub_bindings.each do |binding|
+      # puts "REMOVE: #{binding.inspect}"
+      binding.remove
+      # puts "REMOVED"
+    end
+
+    @sub_bindings = []
+    super
+  end
+  
+  def remove_anchors
+    section.remove_anchors
+  end
+end

data/spec/models/event_chain_spec.rb

@@ -0,0 +1,129 @@
+require 'volt/models'
+
+describe EventChain do
+  before do
+    @a = ReactiveValue.new(1)
+    @b = ReactiveValue.new(2)    
+  end
+  
+  it "should chain events when we use add_object" do
+    
+    count = 0
+    @b.on('changed') { count += 1 }
+    @b.reactive_manager.event_chain.add_object(@a)
+    expect(count).to eq(0)
+    
+    @a.trigger!('changed')
+    expect(count).to eq(1)
+  end
+  
+  it "should chain events after add_object is called" do
+    @b.reactive_manager.event_chain.add_object(@a)
+  
+    add_count = 0
+    @b.on('added') { add_count += 1 }
+    expect(add_count).to eq(0)
+    @a.trigger!('added')
+    
+    expect(add_count).to eq(1) 
+  end
+  
+    
+  it "should remove events" do
+    @b.reactive_manager.event_chain.add_object(@a)
+  
+    add_count = 0
+    listener = @b.on('added') { add_count += 1 }
+    expect(add_count).to eq(0)
+    @a.trigger!('added')
+    
+    expect(add_count).to eq(1)
+    
+    # Make sure the event is registered
+    expect(@a.reactive_manager.listeners.size).to eq(1)
+    expect(@b.reactive_manager.event_chain.instance_variable_get('@event_chain').values[0].keys.include?(:added)).to eq(true)
+    
+    listener.remove
+  
+    # Make sure its removed
+    expect(@a.reactive_manager.listeners.size).to eq(0)
+    expect(@b.reactive_manager.event_chain.instance_variable_get('@event_chain').values[0].keys.include?(:added)).to eq(false)
+    
+    @a.trigger!('added')
+    expect(add_count).to eq(1)
+  end
+  
+  it "should unchain directly" do
+    count = 0
+    a = ReactiveValue.new(Model.new)
+    b = a._name
+    listener = b.on('changed') { count += 1 }
+    
+    expect(b.reactive_manager.listeners[:changed].size).to eq(1)
+    # TODO: ideally this would only bind 1 to a
+    expect(a.reactive_manager.listeners[:changed].size).to eq(1)
+    
+    listener.remove
+    
+    expect(b.reactive_manager.listeners[:changed]).to eq(nil)
+    expect(a.reactive_manager.listeners[:changed]).to eq(nil)
+  end
+  
+  it "should unchain" do
+    count = 0
+    @b.on('changed') { count += 1 }
+    b_object_listener = @b.reactive_manager.event_chain.add_object(@a)
+    expect(count).to eq(0)
+    
+    @a.trigger!('changed')
+    expect(count).to eq(1)
+    
+    b_object_listener.remove
+    
+    @a.trigger!('changed')
+    expect(count).to eq(1)
+  end
+  
+  it "should unchain up the chain" do
+    count = 0
+    a = ReactiveValue.new(Model.new)
+    
+    b = a._list
+    expect(a.reactive_manager.listeners.size).to eq(0)
+    listener = b.on('changed') { count += 1 }
+    
+    expect(a.reactive_manager.listeners.size).to eq(1)
+    
+    listener.remove
+    
+    expect(a.reactive_manager.listeners.size).to eq(0)
+  end
+  
+  describe "double add/removes" do
+    it "should unchain" do
+      c = ReactiveValue.new(3)
+      count = 0
+      @b.on('changed') { count += 1 }
+      c.on('changed') { count += 1 }
+      
+      
+      # Chain b to a
+      b_object_listener = @b.reactive_manager.event_chain.add_object(@a)
+      c_object_listener = c.reactive_manager.event_chain.add_object(@a)
+      expect(count).to eq(0)
+      
+      @a.trigger!('changed')
+      expect(count).to eq(2)
+          
+      b_object_listener.remove
+          
+      @a.trigger!('changed')
+      expect(count).to eq(3)
+      
+      c_object_listener.remove
+      
+      @a.trigger!('changed')
+      expect(count).to eq(3)
+    end
+  end
+end