volt 0.2.3

data/lib/volt/store/mongo.rb

@@ -0,0 +1,5 @@
+require 'mongo'
+
+mongo_client = Mongo::MongoClient.new("localhost", 27017)
+
+db = mongo_client.db("test1")

data/lib/volt/templates/attribute_binding.rb

@@ -0,0 +1,110 @@
+require 'volt/templates/base_binding'
+require 'volt/templates/targets/attribute_target'
+
+class AttributeBinding < BaseBinding
+  def initialize(target, context, binding_name, attribute_name, getter)
+    # puts "New Attribute Binding: #{binding_name}, #{attribute_name}, #{getter}"
+    super(target, context, binding_name)
+
+    @attribute_name = attribute_name
+    @getter = getter
+    
+    setup
+  end
+  
+  def setup
+    
+    # Find the source for the content binding
+    @value = value_from_getter(@getter)
+
+    # Run the initial update (render)
+    update
+
+    @update_listener = @value.on('changed') { update }
+
+    # Bind so when this value updates, we update
+    case @attribute_name
+    when 'value'
+      element.on('input.attrbind') { changed }
+    when 'checked'
+      element.on('change.attrbind') {|event| changed(event) }
+    end
+  end
+
+  def changed(event=nil)
+    case @attribute_name
+    when 'value'
+      current_value = element.value
+      # puts "NEW VAL: #{current_value} : #{@value.inspect}"
+    else
+      current_value = element.is(':checked')
+    end
+
+    @value.cur = current_value
+  end
+
+  def element
+    Element.find('#' + binding_name)
+  end
+
+  def update  
+    if @attribute_target
+      value = @attribute_target.to_html
+    else
+      value = @value.cur
+    end
+
+    if @attribute_name == 'checked'
+      update_checked
+      return
+    end
+    
+    if value.is_a?(NilMethodCall) || value.nil?
+      value = ''
+    end
+
+    self.value = value
+  end
+  
+  def value=(val)
+    case @attribute_name
+    when 'value'
+      element.value = val
+    else
+      element[@attribute_name] = val
+    end
+  end
+  
+  def update_checked
+    value = @value.cur
+    
+    if value.is_a?(NilMethodCall) || value.nil?
+      value = false
+    end
+    
+    if value
+      element['checked'] = 'checked'
+    else
+      element.remove_attr('checked')
+    end
+    
+  end
+  
+  def remove
+    # Unbind events, leave the element there since attribute bindings
+    # aren't responsible for it being there.
+    case @attribute_name
+    when 'value'
+      element.off('input.attrbind')
+    when 'checked'
+      element.off('change.attrbind')
+    end
+    
+    if @update_listener
+      @update_listener.remove
+      @update_listener = nil
+    end
+  end
+
+
+end

data/lib/volt/templates/base_binding.rb

@@ -0,0 +1,37 @@
+class BaseBinding
+  attr_accessor :target, :context, :binding_name
+
+  def initialize(target, context, binding_name)
+    @target = target
+    @context = context
+    @binding_name = binding_name
+
+    @@binding_number ||= 10000
+  end
+
+  def section
+    @section ||= target.section(@binding_name)
+  end
+  
+  def remove
+    section.remove
+  end
+  
+  def remove_anchors
+    section.remove_anchors
+  end
+  
+  def queue_update
+    if Volt.server?
+      # Run right away
+      update
+    else
+      
+    end
+  end
+  
+  def value_from_getter(getter)
+    # Evaluate the getter proc in the context
+    return @context.instance_eval(&getter)
+  end
+end

data/lib/volt/templates/channel.rb

@@ -0,0 +1,48 @@
+# The channel is the connection between the front end and the backend.
+
+require 'volt/reactive/events'
+require 'json'
+
+class Channel
+  include Events
+  
+  def initialize
+    @socket = nil
+    %x{
+      this.socket = new SockJS('http://localhost:3000/channel');//, {reconnect: true});
+
+      this.socket.onopen = function() {
+        console.log('open');
+        self['$trigger!']("open");
+      };
+
+      this.socket.onmessage = function(message) {
+        console.log('received: ', message);
+        self['$message_received'](message.data);
+      };
+    }
+  end
+  
+  def message_received(message)
+    message = JSON.parse(message)
+    puts "Got #{message.inspect}"
+    
+    trigger!('message', message)
+  end
+  
+  def send(message)
+    # TODO: Temp: wrap message in an array, so we're sure its valid JSON
+    message = JSON.dump([message])
+    %x{
+      //message = window.JSON.parse(message);
+      console.log('send: ', message);
+      this.socket.send(message);
+    }
+  end
+  
+  def close
+    %x{
+      this.socket.close();
+    }
+  end
+end

data/lib/volt/templates/content_binding.rb

@@ -0,0 +1,35 @@
+require 'volt/templates/base_binding'
+
+class ContentBinding < BaseBinding
+  def initialize(target, context, binding_name, getter)
+    # puts "new content binding: #{getter}"
+    super(target, context, binding_name)
+
+    # Find the source for the content binding
+    @value = value_from_getter(getter)
+
+    # Run the initial render
+    update
+
+    @changed_listener = @value.on('changed') { update }
+  end
+
+  def update
+    value = @value.cur.or('')
+    
+    # Exception values display the exception as a string
+    value = value.to_s
+    
+    # Update the text in this section
+    section.text = value
+  end
+
+  def remove
+    @changed_listener.remove
+    @changed_listener = nil
+
+    super
+  end
+
+
+end

data/lib/volt/templates/document_events.rb

@@ -0,0 +1,80 @@
+class DocumentEvents
+  def initialize
+    @events = {}
+  end
+
+  def add(event, binding, handler)
+    # Track each document event based on the event, element id, then binding.object_id
+    unless @events[event]
+      # We haven't defined an event of type event yet, lets attach it to the
+      # document.
+
+      @events[event] = {}
+
+      that = self
+
+      %x{
+        $('body').on(event, function(e) {
+          that.$handle(event, e, e.originalEvent.target);
+        });
+      }
+
+    end
+
+    # puts "Register: #{event} - #{binding.binding_name} - #{binding.object_id}"
+
+    @events[event][binding.binding_name] ||= {}
+    @events[event][binding.binding_name][binding.object_id] = handler
+  end
+
+  def handle(event_name, event, target)
+    # puts "Handle: #{event_name} on #{target}"
+    element = Element.find(target)
+
+    loop do
+      # Lookup the handler, make sure to not assume the group
+      # exists.  
+      # TODO: Sometimes the event doesn't exist, but we still get
+      # an event.
+      handlers = @events[event_name]
+      handlers = handlers[element.id] if handlers
+
+      if handlers
+        handlers.values.each do |handler|
+          # Call each handler for this object
+          handler.call(event)
+        end
+      end
+
+      if element.size == 0
+        break
+      else
+        element = element.parent
+      end
+    end
+    
+    nil
+  end
+
+  def remove(event, binding)
+    # Remove the event binding
+    @events[event][binding.binding_name].delete(binding.object_id)
+
+    # if there are no more handlers for this binding_name (the html id), then
+    # we remove the binding name hash
+    if @events[event][binding.binding_name].size == 0
+      @events[event].delete(binding.binding_name)
+    end
+
+    # if there are no more handlers in this event, we can unregister the event
+    # from the document
+    if @events[event].size == 0
+      @events.delete(event)
+      
+      # Remove the event from the body
+      %x{
+        $('body').unbind(event);
+      }
+    end
+  end
+end

data/lib/volt/templates/each_binding.rb

@@ -0,0 +1,115 @@
+require 'volt/templates/base_binding'
+
+class EachBinding < BaseBinding
+  def initialize(target, context, binding_name, getter, variable_name, template_name)
+    # puts "New EACH Binding"
+
+    super(target, context, binding_name)
+
+    @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
+
+    @added_listener = @value.on('added') { |position, item| puts "ADDED" ; item_added(position) }
+    @changed_listener = @value.on('changed') { puts "CHANGED" ; reload }
+    @removed_listener = @value.on('removed') { |position| puts "REMOVED at #{position.inspect}" ; item_removed(position) }
+  end
+  
+  # When a change event comes through, its most likely upstream, so the whole
+  # array might have changed.  In this case, just reload the whole thing
+  # TODO: Track to make sure the changed event isn't being called too often (it is currently)
+  def reload
+    # Remove all of the current templates
+    if @templates
+      @templates.each do |template|
+        template.remove
+        template.remove_anchors
+      end
+    end
+    
+    @templates = []
+    
+    # Run update again to rebuild
+    update
+  end
+
+  def item_removed(position)
+    position = position.cur
+    @templates[position].remove
+    @templates[position].remove_anchors
+    @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
+  end
+
+  def item_added(position)
+    # puts "ADDED AT #{position}"
+    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)
+
+    index = ReactiveValue.new(position)
+    value = @value[index]
+    
+    item_context = SubContext.new({@item_name => value, :index => index, :parent => @value}, @context)
+
+    @templates << TemplateRenderer.new(@target, item_context, binding_name, @template_name)
+  end
+
+  def update(item=nil)
+    if item
+      values = [item]
+    else
+      values = @value.cur
+      return if values.is_a?(Model) || values.is_a?(Exception)
+      values = values.attributes
+    end
+
+    # TODO: Switch to #each?
+    values.each_with_index do |value,index|
+      item_added(index)
+    end
+  end
+
+  # When this each_binding is removed, cleanup.
+  def remove
+    # puts "Remove Each"
+    @added_listener.remove
+    @added_listener = nil
+    
+    @changed_listener.remove
+    @changed_listener = nil
+    
+    @removed_listener.remove
+    @removed_listener = nil
+
+    @templates.each(&:remove)
+    @templates = nil
+    
+    super
+  end
+
+
+end

data/lib/volt/templates/event_binding.rb

@@ -0,0 +1,51 @@
+require 'volt/templates/base_binding'
+
+# TODO: We need to figure out how we want to wrap JS events
+class JSEvent
+  attr_reader :js_event
+  def initialize(js_event)
+    @js_event = js_event
+  end
+  
+  def key_code
+    `this.js_event.keyCode`
+  end
+
+  def stop
+    # puts "STOPPING"
+    # `this.js_event.stopPropagation();`
+    `this.js_event.preventDefault();`
+  end
+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
+    @event_name = event_name
+    
+    handler = Proc.new do |js_event|
+      event = JSEvent.new(js_event)
+      event.stop if event_name == 'submit'
+
+      # Call the proc the user setup for the event in context,
+      # pass in the wrapper for the JS event
+      result = @context.instance_exec(event, &call_proc)
+    end
+
+    @listener = $page.events.add(event_name, self, handler)
+  end
+
+  def element
+    Element.find('#' + binding_name)
+  end
+
+  # Remove the event binding
+  def remove
+    # puts "REMOVE EL FOR #{@event}"
+    $page.events.remove(@event_name, self)
+  end
+end