volt 0.3.7 → 0.3.8

data/lib/volt/{templates → page/bindings}/template_binding.rb

@@ -1,5 +1,5 @@
-require 'volt/templates/base_binding'
-require 'volt/templates/template_renderer'
+require 'volt/page/bindings/base_binding'
+require 'volt/page/template_renderer'
 
 class TemplateBinding < BaseBinding
   def initialize(target, context, binding_name, binding_in_path, getter)
@@ -131,7 +131,7 @@ class TemplateBinding < BaseBinding
       controller = get_controller(controller_name)
       
       # Initialize the new controller
-      current_context = controller.new(*args)
+      current_context = (ModelController || controller).new(*args)
     elsif @model
       # Passed in attributes, but there is no controller
       current_context = SubContext.new(@model, current_context)      
@@ -169,14 +169,23 @@ class TemplateBinding < BaseBinding
       # For the home object, we do not need to namespace our controller
       if controller_name[0] != 'home'
         # Controller is namespaced, lookup outer module first
-        base_name = controller_name[0].camelize
-        base_object = Object.send(:const_get, base_name.to_sym)
+        base_name = controller_name[0].camelize.to_sym
+        if Object.send(:const_defined?, base_name)
+          base_object = Object.send(:const_get, base_name)
+        end
       else
         # Get controller directlry
         base_object = Object
       end
-    
-      base_object.send(:const_get, (name + 'Controller').to_sym)
+      
+      if base_object
+        name = (name + 'Controller').to_sym
+        if base_object.send(:const_defined?, name)
+          return base_object.send(:const_get, name)
+        end
+      end
+
+      return nil
     end
   
 end

data/lib/volt/page/channel.rb

@@ -0,0 +1,105 @@
+# The channel is the connection between the front end and the backend.
+
+require 'volt/reactive/events'
+require 'json'
+
+class Channel
+  include ReactiveTags
+  
+  attr_reader :state, :error, :reconnect_interval
+  
+  def initialize
+    @socket = nil
+    @state = :opening
+    @error = nil
+    @queue = []
+    
+    connect!
+  end
+  
+  def connect!
+    %x{
+      this.socket = new SockJS('http://localhost:3000/channel');
+
+      this.socket.onopen = function() {
+        self.$opened();
+      };
+
+      this.socket.onmessage = function(message) {
+        self['$message_received'](message.data);
+      };
+      
+      this.socket.onclose = function(error) {
+        self.$closed(error);
+      };
+    }
+  end
+  
+  def opened
+    @state = :open
+    @reconnect_interval = nil
+    @queue.each do |message|
+      send_message(message)
+    end
+    
+    trigger!('open')
+    trigger!('changed')
+  end
+
+  def closed(error)
+    @state = :closed
+    @error = `error.reason`
+    
+    trigger!('closed')
+    trigger!('changed')
+    
+    reconnect!
+  end
+  
+  def reconnect!
+    @reconnect_interval ||= 0
+    @reconnect_interval += (2000 + rand(5000))
+    
+    # Trigger changed for reconnect interval
+    trigger!('changed')
+    
+    interval = @reconnect_interval
+    
+    %x{
+      setTimeout(function() {
+        self['$connect!']();
+      }, interval);
+    }
+  end
+  
+  def message_received(message)
+    message = JSON.parse(message)
+    # puts "GOT: #{message.inspect}"
+    trigger!('message', nil, *message)
+  end
+  
+  tag_method(:send_message) do
+    destructive!
+  end
+  def send_message(message)
+    `console.log('do send message');`
+    puts "Send #{message.inspect}"
+    if @state != :open
+      @queue << message
+      puts "Queue"
+    else
+      # TODO: Temp: wrap message in an array, so we're sure its valid JSON
+      message = JSON.dump([message])
+      %x{
+        this.socket.send(message);
+      }
+    end
+  end
+  
+  def close!
+    @state = :closed
+    %x{
+      this.socket.close();
+    }
+  end
+end

data/lib/volt/{templates → page}/page.rb

@@ -6,24 +6,25 @@ 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/page/bindings/attribute_binding'
+require 'volt/page/bindings/content_binding'
+require 'volt/page/bindings/each_binding'
+require 'volt/page/bindings/if_binding'
+require 'volt/page/bindings/template_binding'
+require 'volt/page/bindings/event_binding'
+require 'volt/page/template_renderer'
+require 'volt/page/reactive_template'
+require 'volt/page/document_events'
+require 'volt/page/sub_context'
+require 'volt/page/targets/dom_target'
+require 'volt/page/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'
+require 'volt/page/render_queue'
+require 'volt/page/tasks'
 
 class Page
   attr_reader :url, :params, :page, :store, :templates, :routes, :render_queue
@@ -36,7 +37,7 @@ class Page
     
     # 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))
+    @store = ReactiveValue.new(Store.new(tasks))#({}, nil, 'store', @model_classes))
     
     @url = ReactiveValue.new(URL.new)
     @params = @url.params
@@ -63,10 +64,10 @@ class Page
         return false;
       });
     }
-
-    channel.on('message') do |message|
-      puts "GOT: #{message}"
-    end
+  end
+  
+  def tasks
+    @tasks ||= Tasks.new(self)
   end
   
   def link_clicked(url)
@@ -74,9 +75,9 @@ class Page
     return if url.blank?
 
     # Normalize url
-    # Benchmark.bm(1) do
+    Benchmark.bm(1) do
       @url.parse("http://localhost:3000" + url)
-    # end
+    end
   end
   
   # We provide a binding_name, so we can bind events on the document
@@ -89,7 +90,7 @@ class Page
   end
 
   def channel
-    @channel ||= Channel.new
+    @channel ||= ReactiveValue.new(Channel.new)
   end
 
   def events

data/lib/volt/{templates → page}/targets/attribute_section.rb

@@ -1,7 +1,7 @@
 # AttributeSection provides a place to render templates that
 # will be placed as text into an attribute.
 
-require 'volt/templates/targets/base_section'
+require 'volt/page/targets/base_section'
 
 class AttributeSection
   def initialize(target, binding_name)

data/lib/volt/{templates → page}/targets/attribute_target.rb

@@ -1,7 +1,7 @@
-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'
+require 'volt/page/targets/base_section'
+require 'volt/page/targets/attribute_section'
+require 'volt/page/targets/binding_document/component_node'
+require 'volt/page/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.

data/lib/volt/{templates → page}/targets/binding_document/component_node.rb

@@ -1,4 +1,4 @@
-require 'volt/templates/targets/binding_document/html_node'
+require 'volt/page/targets/binding_document/html_node'
 require 'volt/reactive/events'
 
 # Component nodes contain an array of both HtmlNodes and ComponentNodes.

data/lib/volt/{templates → page}/targets/binding_document/html_node.rb

@@ -1,4 +1,4 @@
-require 'volt/templates/targets/binding_document/base_node'
+require 'volt/page/targets/binding_document/base_node'
 
 class HtmlNode < BaseNode
   def initialize(html)

data/lib/volt/{templates → page}/targets/dom_section.rb

@@ -1,4 +1,4 @@
-require 'volt/templates/targets/base_section'
+require 'volt/page/targets/base_section'
 
 class DomSection < BaseSection
   def initialize(binding_name)

data/lib/volt/{templates → page}/targets/dom_target.rb

@@ -1,5 +1,5 @@
-require 'volt/templates/targets/base_section'
-require 'volt/templates/targets/dom_section'
+require 'volt/page/targets/base_section'
+require 'volt/page/targets/dom_section'
 
 # DomTarget's provide an interface that can render bindings into
 # the dom.  Currently only one "dom" is supported, but multiple

data/lib/volt/page/tasks.rb

@@ -0,0 +1,61 @@
+# The tasks class provides an interface to call tasks on
+# the backend server.
+class Tasks
+  def initialize(page)
+    @page = page
+    @callback_id = 0
+    @callbacks = {}
+    
+    page.channel.on('message') do |_, *args|
+      received_message(*args)
+    end
+  end
+  
+  def call(class_name, method_name, *args, &callback)
+    if callback
+      callback_id = @callback_id
+      @callback_id += 1
+
+      # Track the callback
+      # TODO: Timeout on these callbacks
+      @callbacks[callback_id] = callback
+    else
+      callback_id = nil
+    end
+    
+    @page.channel.send_message([callback_id, class_name, method_name, *args])
+  end
+  
+  
+  def received_message(name, callback_id, *args)
+    case name
+    when 'response'
+      response(callback_id, *args)
+    when 'update'
+      update(*args)
+    when 'reload'
+      reload
+    end
+  end
+  
+  def response(callback_id, *args)
+    callback = @callbacks.delete(callback_id)
+    
+    if callback
+      callback.call(*args)
+    end
+  end
+  
+  def update(model_id, data)
+    $loading_models = true
+    puts "UPDATE: #{model_id} with #{data.inspect}"
+    Store.update(model_id, data)
+    $loading_models = false
+  end
+  
+  def reload
+    puts "RELOAD"
+    $page.page._reloading = true
+    `window.location.reload(false);`
+  end
+end

data/lib/volt/{templates → page}/template_renderer.rb

@@ -1,4 +1,4 @@
-require 'volt/templates/base_binding'
+require 'volt/page/bindings/base_binding'
 
 class TemplateRenderer < BaseBinding
   attr_reader :context

data/lib/volt/reactive/destructive_methods.rb

@@ -0,0 +1,19 @@
+# DestructiveMethods tracks the names of all methods that are marked as 
+# destructive.  This lets us do an optimization where we don't need to 
+# check any methods with names that aren't here, we can be sure that they
+# are not destructive.  If the method is tracked here, we need to check
+# it on its current class.
+class DestructiveMethods
+  @@method_names = {}
+  
+  def self.add_method(method_name)
+    @@method_names[method_name] = true
+  end
+  
+  # Check to see if a method might be destructive.  If this returns
+  # false, then we can guarentee that it won't be destructive and
+  # we can skip a destructive check.
+  def self.might_be_destructive?(method_name)
+    return @@method_names[method_name]
+  end
+end

data/lib/volt/reactive/event_chain.rb

@@ -40,40 +40,34 @@ class EventChain
   
   # Register an event listener that chains from object to self
   def setup_listener(event, chain_listener)
-    return chain_listener.object.on(event, @main_object) do |*args|
+    return chain_listener.object.on(event, @main_object) do |filter, *args|
       if callback = chain_listener.callback
-        callback.call(event, *args)
+        callback.call(event, filter, *args)
       else
         # Trigger on this value, when it happens on the parent
-        @main_object.trigger!(event, *args)
+        
+        # Only pass the filter from non-reactive to reactive?  This
+        # lets us scope the calls on a proxied object.
+        # Filters limit which listeners are triggered, passing them to 
+        # the ReactiveValue's from non-reactive lets us filter at the
+        # reactive level as well.
+        filter = nil unless !chain_listener.object.reactive? && @main_object.reactive?
+        
+        @main_object.trigger!(event, filter, *args)
       end
     end
   end
-  
-  def all_listening_events
-    all_listeners = []
-    all_listeners += @main_object.listeners.keys
-    
-    if @main_object
-      @main_object.event_followers.each do |event_follower|
-        all_listeners += event_follower.listeners.keys
-      end
-    end
     
-    return all_listeners.uniq
-  end
-
-  
   # We can chain our events to any other object that includes
   # Events
   def add_object(object, &block) 
     # puts "ADD OBJECT: #{object.inspect} to #{self.inspect}" 
-      
+    
     chain_listener = ChainListener.new(self, object, block)
 
     listeners = {}
     
-    all_listening_events.uniq.each do |event|
+    @main_object.listeners.keys.each do |event|
       # Create a listener for each event
       listeners[event] = setup_listener(event, chain_listener)
     end

data/lib/volt/reactive/events.rb

@@ -6,7 +6,7 @@ DEBUG = false
 # A listener gets returned when adding an 'on' event listener.  It can be
 # used to clear the event listener.
 class Listener
-  attr_reader :scope_provider
+  attr_reader :scope_provider, :klass
   
   def initialize(klass, event, scope_provider, callback)
     @klass = klass
@@ -43,13 +43,13 @@ class Listener
   end
   
   def scope
-    @scope_provider && @scope_provider.scope
+    @scope_provider && scope_provider.respond_to?(:scope) && @scope_provider.scope
   end
   
   def call(*args)
     # raise "Triggered on removed: #{@event} on #{@klass2.inspect}" if @removed
     if @removed
-      puts "Triggered on removed: #{@event}"
+      puts "Triggered on a removed event: #{@event}"
       return
     end
     
@@ -98,7 +98,6 @@ class Listener
 end
 
 module Events
-  attr_accessor :scope
   # Add a listener for an event
   def on(event, scope_provider=nil, &block) 
     # puts "Register: #{event} on #{self.inspect}"   
@@ -111,7 +110,10 @@ module Events
     @listeners[event] << new_listener
 
     first = @listeners[event].size == 1
-    add_event_to_chains(event) if first
+    
+    # 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
 
     # Let the included class know that an event was registered. (if it cares)
     if self.respond_to?(:event_added)
@@ -144,7 +146,9 @@ module Events
 
       no_more_events = @listeners[event].size == 0
       if no_more_events
-        remove_event_from_chains(event)
+        # When events are removed, we need to notify any relevent chains so they
+        # can remove any chained events.
+        event_chain.remove_event(event)
 
         # No registered listeners now on this event
         @listeners.delete(event)
@@ -157,110 +161,29 @@ module Events
       end
     # end
   end
-  
-  # When events get added, we need to notify event chains so they
-  # can update and chain any new events.
-  def add_event_to_chains(event)
-    # First time this event is added, update any chains
-    event_chain.add_event(event)
-
-    # We need to keep the event chain's updated for any objects we're
-    # following for events.
-    event_followings.each {|ef| ef.event_chain.add_event(event) }
-
-    if event != :changed && !@other_event_listener
-      @other_event_listener = on('changed') { }
-    end
-  end
-  
-  # When events are removed, we need to notify any relevent chains so they
-  # can remove any chained events.
-  def remove_event_from_chains(event)
-    event_chain.remove_event(event)
     
-    # We need to keep the event chain's updated for any objects we're
-    # following for events.
-    event_followings.each {|ef| ef.event_chain.remove_event(event) }
-
-    if event != :changed
-      # See if there are any remaining events that aren't changed
-      if listeners.keys.reject {|k| k == :changed }.size == 0
-        @other_event_listener.remove
-        @other_event_listener = nil
-      end
-    end
-  end
-  
-  
-  # Track the current object that we're following.
-  def event_followings
-    @event_followings || []
-  end
-
-  def add_following(object)
-    @event_followings ||= []
-    @event_followings << object
-    
-    # Take all of our listeners and add them to the 
-    listeners.keys.each do |event|
-      object.event_chain.add_event(event)
-    end
-  end
-  
-  def remove_following(object) 
-    @event_followings.delete(object)
-       
-    listeners.keys.each do |event|
-      object.event_chain.remove_event(event)
-    end
-  end
-  
-  # Track who's following us
-  def event_followers
-    @event_followers || []
-  end
-  
-  def add_event_follower(follower)
-    @event_followers ||= []
-    @event_followers << follower
-    
-    follower.add_following(self)
-  end
-  
-  def remove_event_follower(follower)
-    if @event_followers
-      @event_followers.delete(follower)
-    
-      follower.remove_following(self)
-    end
-  end
-
-  # Return all listeners for an event on the current object and any event 
-  # following objects.
-  def all_listeners_for(event)
-    # TODO: We dup at the moment because some events unregister events, is there
-    # a better solution than this?
-    all_listeners = []
-    all_listeners += @listeners[event].dup if @listeners && @listeners[event]
-
-    if @event_followers
-      @event_followers.each do |event_follower|
-        ef_listeners = event_follower.listeners
-        all_listeners += ef_listeners[event].dup if ef_listeners[event]
-      end
-    end
-    
-    return all_listeners
-  end
-
-  def trigger!(event, *args)
-    ObjectTracker.process_queue if !reactive? && !respond_to?(:skip_current_queue_flush)
+  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)
     
     event = event.to_sym
     
-    all_listeners_for(event).each do |listener|
-      # Call the event on each listener
-      listener.call(*args)
+    if @listeners && @listeners[event]
+      # puts "LISTENERS FOR #{event} on #{self.inspect} - #{@listeners[event].inspect}"
+      # TODO: We have to dup here because one trigger might remove another
+      @listeners[event].dup.each do |listener|
+        # Call the event on each listener
+        # If there is no listener, that means another event trigger removed it.
+        # If there is no filter, call
+        # if we aren't reactive, we should pass to all of our reactive listeners, since they
+        # just proxy us.
+        # If the filter exists, check it
+        # puts "CHECK #{listener.inspect} : #{self.inspect} -- #{listener.klass.inspect}"   
+        if (!filter || (!are_reactive && listener.scope_provider.reactive?) || filter.call(listener.scope))
+          listener.call(filter, *args)
+        end
+      end
     end
 
     nil
@@ -268,16 +191,7 @@ module Events
   
   # Takes a block, which passes in 
   def trigger_by_scope!(event, *args, &block)
-    ObjectTracker.process_queue if !reactive? && !respond_to?(:skip_current_queue_flush)
-    
-    event = event.to_sym
-    
-    all_listeners_for(event).each do |listener|
-      # Call the block, pass in the scope
-      if block.call(listener.scope)
-        listener.call(*args)
-      end
-    end
+    trigger!(event, block, *args)
   end
 
 end