volt 0.2.3

data/lib/volt/templates/if_binding.rb

@@ -0,0 +1,74 @@
+require 'volt/templates/base_binding'
+
+class IfBinding < BaseBinding
+  def initialize(target, context, binding_name, branches)
+    getter, template_name = branches[0]
+    # puts "New If Binding: #{binding_name}, #{getter.inspect}"
+
+
+    super(target, context, binding_name)
+
+    @branches = []
+    @listeners = []
+    
+    branches.each do |branch|
+      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
+      else
+        # A nil value means this is an unconditional else branch, it
+        # should always be true
+        value = true
+      end
+      
+      @branches << [value, template_name]
+    end
+    
+    update
+  end
+  
+  def update
+    # Find the true branch
+    true_template = nil
+    @branches.each do |branch|
+      value, template_name = branch
+      
+      # TODO: A bug in opal requires us to check == true
+      if value.cur.true? == true
+        # This branch is currently true
+        true_template = template_name
+        break
+      end
+    end
+    
+    # Change out the template only if the true branch has changed.
+    if @last_true_template != true_template
+      @last_true_template = true_template
+      
+      if @template
+        @template.remove
+        @template = nil
+      end
+      
+      if true_template
+        @template = TemplateRenderer.new(@target, @context, binding_name, true_template)
+      end
+    end
+  end
+  
+  def remove
+    # Remove all listeners on any reactive values
+    @listeners.each(&:remove)
+
+    @template.remove if @template
+    
+    super
+  end
+end

data/lib/volt/templates/memory_test.rb

@@ -0,0 +1,26 @@
+require 'opal'
+require 'volt/models'
+
+class Test
+  def self.test1
+    a = ReactiveValue.new(1)
+    listener = a.on('changed') { puts "CHANGED" }
+    a.cur = 5
+    listener.remove
+    
+    ObjectTracker.process_queue
+  end
+  
+  def self.test
+    a = ReactiveValue.new(Model.new)
+    a._cool = [1,2,3]
+    
+    listener = a._cool.on('added') { puts "ADDED" }
+    a._cool << 4
+    puts a._cool[3]
+    
+    listener.remove
+    
+    ObjectTracker.process_queue
+  end
+end

data/lib/volt/templates/page.rb

@@ -0,0 +1,146 @@
+require 'opal'
+
+ENV['CLIENT'] = true
+
+require 'opal-jquery'
+require 'volt/models'
+require 'volt/models/params'
+require 'volt/controllers/model_controller'
+require 'volt/templates/attribute_binding'
+require 'volt/templates/content_binding'
+require 'volt/templates/each_binding'
+require 'volt/templates/if_binding'
+require 'volt/templates/template_binding'
+require 'volt/templates/template_renderer'
+require 'volt/templates/reactive_template'
+require 'volt/templates/event_binding'
+require 'volt/templates/document_events'
+require 'volt/templates/sub_context'
+require 'volt/templates/targets/dom_target'
+require 'volt/templates/channel'
+require 'volt/router/routes'
+require 'volt/models/url'
+require 'volt/page/url_tracker'
+require 'volt'
+require 'volt/benchmark/benchmark'
+require 'volt/templates/render_queue'
+
+class Page
+  attr_reader :url, :params, :page, :store, :templates, :routes, :render_queue
+
+  def initialize
+
+    # debugger
+    puts "------ Page Loaded -------"
+    @model_classes = {}
+    
+    # Run the code to setup the page
+    @page = ReactiveValue.new(Model.new)#({}, nil, 'page', @model_classes))
+    @store = ReactiveValue.new(Model.new)#({}, nil, 'store', @model_classes))
+    
+    @url = ReactiveValue.new(URL.new)
+    @params = @url.params
+    @url_tracker = UrlTracker.new(self)
+
+    @events = DocumentEvents.new
+    @render_queue = RenderQueue.new
+    
+    # Add event for link clicks to handle all a onclick
+    # EventBinding.new(self, )
+    
+    # Setup escape binding for console
+    %x{
+      $(document).keyup(function(e) {
+        if (e.keyCode == 27) {
+          Opal.gvars.page.$launch_console();
+        }
+      });
+      
+      $(document).on('click', 'a', function(event) {        
+        Opal.gvars.page.$link_clicked($(this).attr('href'));
+        event.stopPropagation();
+        
+        return false;
+      });
+    }
+
+    # channel
+    # channel.on('message') do |message|
+    #   # puts "GOT: #{message}"
+    #   # `console.log('got: ', message);`
+    # end
+  end
+  
+  def link_clicked(url)
+    puts "Link Clicked to: #{url}"
+    # Skip when href == ''
+    return if url.blank?
+
+    # Normalize url
+    # Benchmark.bm(1) do
+      @url.parse("http://localhost:3000" + url)
+    # end
+  end
+  
+  # We provide a binding_name, so we can bind events on the document
+  def binding_name
+    'page'
+  end
+  
+  def launch_console
+    puts "Launch Console"
+  end
+
+  def channel
+    @channel ||= Channel.new
+  end
+
+  def events
+    @events
+  end
+  
+  def add_model(model_name)
+    # puts "ADD MODEL: #{model_name.inspect} - #{model_name.camelize.inspect}"
+    
+    @model_classes[["*", "_#{model_name}"]] = Object.const_get(model_name.camelize)
+  end
+
+  def add_template(name, template, bindings)
+    # puts "Add Template: #{name}\n#{template.inspect}\n#{bindings.inspect}"
+    @templates ||= {}
+    @templates[name] = {'html' => template, 'bindings' => bindings}
+    # puts "Add Template: #{name}"
+  end
+  
+  def add_routes(&block)
+    @routes = Routes.new.define(&block)
+    @url.cur.router = @routes
+  end
+
+  def start
+    # Setup to render template
+    Element.find('body').html = "<!-- $CONTENT --><!-- $/CONTENT -->"
+
+    main_controller = IndexController.new
+
+    # Setup main page template
+    TemplateRenderer.new(DomTarget.new, main_controller, 'CONTENT', 'home/index/index/body')
+
+    # Setup title listener template
+    title_target = AttributeTarget.new
+    title_target.on('changed') do
+      title = title_target.to_html
+      `document.title = title;`
+    end
+    TemplateRenderer.new(title_target, main_controller, "main", "home/index/index/title")
+    
+    @url_tracker.url_updated(true)
+  end
+end
+
+$page = Page.new
+
+# Call start once the page is loaded
+Document.ready? do
+  $page.start
+end

data/lib/volt/templates/reactive_template.rb

@@ -0,0 +1,38 @@
+class ReactiveTemplate
+  include Events
+  
+  def initialize(context, template_path)
+    @template_path = template_path
+    @target = AttributeTarget.new
+    @template = TemplateRenderer.new(@target, context, "main", template_path)
+  end
+  
+  def event_added(event, scope_provider, first)
+    if first && !@template_listener
+      @template_listener = @target.on('changed') { update }
+    end
+  end
+  
+  def event_removed(event, last)
+    if last && @template_listener
+      @template_listener.remove
+      @template_listener = nil
+    end
+  end
+  
+  # Render the template and get the current value
+  def cur
+    @target.to_html
+  end
+  
+  # TODO: improve
+  def skip_current_queue_flush
+    true
+  end
+  
+  
+  def update
+    trigger!('changed')
+  end
+  
+end

data/lib/volt/templates/render_queue.rb

@@ -0,0 +1,5 @@
+class RenderQueue
+  def initialize
+    # @queue
+  end
+end

data/lib/volt/templates/sub_context.rb

@@ -0,0 +1,23 @@
+# A sub context takes in a hash of local variables that should be available
+# in front of the current context.  It basically proxies the local variables 
+# first, then failing those proxies the context.
+
+class SubContext
+  attr_reader :locals
+  
+  def initialize(locals, context=nil)
+    @locals = locals.stringify_keys
+    @context = context
+  end
+  
+  def method_missing(method_name, *args, &block)
+    method_name = method_name.to_s
+    if @locals[method_name]
+      return @locals[method_name]
+    elsif @context
+      return @context.send(method_name, *args, &block)
+    end
+
+    raise NoMethodError.new("undefined method `#{method_name}' for \"#{self.inspect}\":#{self.class.to_s}")
+  end
+end

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

@@ -0,0 +1,33 @@
+# AttributeSection provides a place to render templates that
+# will be placed as text into an attribute.
+
+require 'volt/templates/targets/base_section'
+
+class AttributeSection
+  def initialize(target, binding_name)
+    @target = target
+    @binding_name = binding_name
+    # puts "init attr section on #{binding_name}"
+  end
+  
+  def text=(text)
+    set_content_and_rezero_bindings(text, {})
+  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)
+    if @binding_name == 'main'
+      @target.html = html
+    else
+      @target.find_by_binding_id(@binding_name).html = html
+    end
+    
+    return bindings
+  end
+  
+  def remove
+    node = @target.find_by_binding_id(@binding_name)
+    node.remove
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'volt/templates/targets/base_section'
+require 'volt/templates/targets/attribute_section'
+require 'volt/templates/targets/binding_document/component_node'
+require 'volt/templates/targets/binding_document/html_node'
+
+# AttributeTarget's provide an interface that can render bindings into
+# a string that can then be used to update a attribute binding.
+
+class AttributeTarget < ComponentNode  
+  # TODO: improve
+  def skip_current_queue_flush
+    true
+  end
+  
+  def section(*args)
+    return AttributeSection.new(self, *args)
+  end
+end

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

@@ -0,0 +1,14 @@
+# Class to describe the interface for sections
+class BaseSection
+  def remove
+    raise "not implemented"
+  end
+
+  def remove_anchors
+    raise "not implemented"
+  end
+  
+  def insert_anchor_before_end
+    raise "not implemented"
+  end
+end

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

@@ -0,0 +1,3 @@
+class BaseNode
+
+end

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

@@ -0,0 +1,112 @@
+require 'volt/templates/targets/binding_document/html_node'
+require 'volt/reactive/events'
+
+# Component nodes contain an array of both HtmlNodes and ComponentNodes.
+# Instead of providing a full DOM API, component nodes are the branch
+# nodes and html nodes are the leafs.  This is all we need to produce
+# the html from templates outside of a normal dom.
+class ComponentNode < BaseNode
+  include Events
+  
+  attr_accessor :parent, :binding_id, :nodes
+  def initialize(binding_id=nil, parent=nil)
+    @nodes = []
+    @binding_id = binding_id
+    @parent = parent
+    
+    @change_listener = on('changed') do
+      if @parent
+        @parent.trigger!('changed')
+      end
+    end
+  end
+
+  # TODO: improve
+  def skip_current_queue_flush
+    true
+  end
+  
+  def text=(text)
+    self.html = text
+  end
+  
+  def html=(html)
+    parts = html.split(/(\<\!\-\- \$\/?[0-9]+ \-\-\>)/).reject {|v| v == '' }
+  
+    # Clear current nodes
+    @nodes = []
+    
+    current_node = self
+  
+    parts.each do |part|
+      case part
+      when /\<\!\-\- \$[0-9]+ \-\-\>/
+        # Open
+        binding_id = part.match(/\<\!\-\- \$([0-9]+) \-\-\>/)[1].to_i
+      
+        sub_node = ComponentNode.new(binding_id, current_node)
+        current_node << sub_node
+        current_node = sub_node
+      when /\<\!\-\- \$\/[0-9]+ \-\-\>/
+        # Close
+        # binding_id = part.match(/\<\!\-\- \$\/([0-9]+) \-\-\>/)[1].to_i
+      
+        current_node = current_node.parent
+      else
+        # html string
+        current_node << HtmlNode.new(part)
+      end
+    end
+    
+    trigger!('changed')
+  end
+  
+  def <<(node)
+    @nodes << node
+  end
+  
+  def to_html
+    str = []
+    @nodes.each do |node|
+      str << node.to_html
+    end
+    
+    return str.join('')
+  end
+  
+  def find_by_binding_id(binding_id)
+    if @binding_id == binding_id
+      return self
+    end
+    
+    @nodes.each do |node|
+      if node.cur.is_a?(ComponentNode)
+        val = node.find_by_binding_id(binding_id)
+        return val if val
+      end
+    end
+    
+    return nil
+  end
+  
+  def remove
+    @nodes = []
+    
+    trigger!('changed')
+  end
+  
+  def remove_anchors
+    raise "not implemented"
+
+    @parent.nodes.delete(self)
+        
+    @change_listener.remove
+    @change_listener = nil
+    
+    trigger!('changed')
+  end
+  
+  def inspect
+    "<ComponentNode:#{@binding_id} #{@nodes.inspect}>"
+  end
+end