volt 0.6.5 → 0.7.0

data/lib/volt/page/template_renderer.rb

@@ -32,7 +32,7 @@ class TemplateRenderer < BaseBinding
 
     # Remove all of the sub-bindings
     # @sub_bindings.each(&:remove)
-    
+
     @sub_bindings.each do |binding|
       # puts "REMOVE: #{binding.inspect}"
       binding.remove
@@ -40,11 +40,11 @@ class TemplateRenderer < BaseBinding
     end
 
     @sub_bindings = []
-    
+
     super
   end
-  
+
   def remove_anchors
     section.remove_anchors
   end
-end
+end

data/lib/volt/page/url_tracker.rb

@@ -4,14 +4,14 @@
 class UrlTracker
   def initialize(page)
     @page = page
-    
+
     if Volt.client?
       page.params.on('child_changed') do
         @page.url.update!
       end
 
       that = self
-      
+
       # Setup popstate on the dom ready event.  Prevents an extra
       # popstate trigger
       %x{
@@ -20,17 +20,17 @@ class UrlTracker
           if (first === false) {
             that.$url_updated();
           }
-          
+
           first = false;
-        
+
           return true;
         });
       }
     end
   end
-  
+
   def url_updated(first_call=false)
     @page.url.parse(`document.location.href`)
     @page.url.update! unless first_call
   end
-end
+end

data/lib/volt/reactive/array_extensions.rb

@@ -7,7 +7,7 @@ class Array
     if val.reactive? && !result.reactive?
       result = ReactiveValue.new(result)
     end
-  
+
     return result
   end
-end
+end

data/lib/volt/reactive/destructive_methods.rb

@@ -1,19 +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 
+# 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
+end

data/lib/volt/reactive/event_chain.rb

@@ -2,29 +2,29 @@ CHAIN_DEBUG = false
 
 class ChainListener
   attr_reader :object, :callback
-  
+
   def initialize(event_chain, object, callback)
     @event_chain = event_chain
     @object = object
     @callback = callback
-    
+
     if RUBY_PLATFORM == 'opal' && CHAIN_DEBUG
       `window.chain_listeners = window.chain_listeners || 0;`
       `window.chain_listeners += 1;`
       `console.log('chain listeners: ', window.chain_listeners)`
     end
   end
-  
+
   def remove
     raise "event chain already removed" if @removed
     @removed = true
     @event_chain.remove_object(self)
-    
+
     # We need to clear these to free memory
     @event_chain = nil
     @object = nil
     @callback = nil
-    
+
     if RUBY_PLATFORM == 'opal' && CHAIN_DEBUG
       `window.chain_listeners -= 1;`
     end
@@ -37,7 +37,7 @@ class EventChain
     @main_object = main_object
     @event_counts = {}
   end
-  
+
   # 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 |filter, *args|
@@ -45,73 +45,73 @@ class EventChain
         callback.call(event, filter, *args)
       else
         # Trigger on this value, when it happens on the parent
-        
+
         # 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 
+        # 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
-    
+
   # 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}" 
-    
+  def add_object(object, &block)
+    # puts "ADD OBJECT: #{object.inspect} to #{self.inspect}"
+
     chain_listener = ChainListener.new(self, object, block)
 
     listeners = {}
-    
+
     @main_object.listeners.keys.each do |event|
       # Create a listener for each event
       listeners[event] = setup_listener(event, chain_listener)
     end
-    
+
     @event_chain[chain_listener] = listeners
-    
+
     return chain_listener
   end
-  
-  
+
+
   def remove_object(chain_listener)
     @event_chain[chain_listener].each_pair do |event,listener|
       # Unbind each listener
       listener.remove
     end
-    
+
     @event_chain.delete(chain_listener)
   end
-  
+
   def add_event(event)
     unless @event_counts[event]
       @event_chain.each_pair do |chain_listener,listeners|
-        # Only add if we haven't already chained this event  
+        # Only add if we haven't already chained this event
         unless listeners[event]
           listeners[event] = setup_listener(event, chain_listener)
         end
       end
     end
-    
+
     @event_counts[event] ||= 0
     @event_counts[event] += 1
   end
-  
+
   # Removes the event from all events in all objects
   def remove_event(event)
     if @event_counts[event]
       count = @event_counts[event] -= 1
-      
+
       if count == 0
         @event_chain.each_pair do |chain_listener,listeners|
           listeners[event].remove# if listeners[event]
           listeners.delete(event)
         end
-        
+
         # Also remove the event count
         @event_counts.delete(event)
       end

data/lib/volt/reactive/events.rb

@@ -7,7 +7,7 @@ DEBUG = false
 # used to clear the event listener.
 class Listener
   attr_reader :scope_provider, :klass
-  
+
   def initialize(klass, event, scope_provider, callback)
     @klass = klass
     @event = event
@@ -18,41 +18,41 @@ class Listener
       # puts "e: #{event} on #{klass.inspect}"
       @@all_events ||= []
       @@all_events << self
-      
+
       # counts = {}
       # @@all_events.each do |ev|
       #   scope = (ev.scope_provider && ev.scope_provider.scope) || nil
-      #   
+      #
       #   # puts `typeof(scope)`
       #   if `typeof(scope) !== 'undefined'`
       #     counts[scope] ||= 0
       #     counts[scope] += 1
       #   end
       # end
-      # 
+      #
       # puts counts.inspect
-      
+
       `window.total_listeners = window.total_listeners || 0;`
       `window.total_listeners += 1;`
       `console.log(window.total_listeners);`
     end
   end
-  
+
   def internal?
     @internal
   end
-  
+
   def 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 a removed event: #{@event}"
       return
     end
-    
+
     # Queue a live value update
     if @klass.reactive?
       # We are working with a reactive value.  Its receiving an event meaning
@@ -60,7 +60,7 @@ class Listener
       @klass.object_tracker.queue_update
       # puts "Queued: #{ObjectTracker.queue.inspect}"
     end
-    
+
     @callback.call(*args)
   end
 
@@ -68,16 +68,16 @@ class Listener
   def remove
     # puts "FAIL:" if @removed
     raise "event #{@event} already removed" if @removed
-    
+
     # puts "e rem: #{@event} on #{@klass.inspect}"
     if DEBUG && RUBY_PLATFORM == 'opal'
       @@all_events.delete(self) if @@all_events
-      
+
       `window.total_listeners -= 1;`
       `console.log("Rem", window.total_listeners);`
     end
-    
-    
+
+
     @removed = true
     @klass.remove_listener(@event, self)
 
@@ -91,7 +91,7 @@ class Listener
     # @event = nil
 
   end
-  
+
   def inspect
     "<Listener:#{object_id} event=#{@event} scope=#{scope.inspect}#{' internal' if internal?}>"
   end
@@ -99,26 +99,26 @@ end
 
 module Events
   # Add a listener for an event
-  def on(event, scope_provider=nil, &block) 
+  def on(event, scope_provider=nil, &block)
+
 
-    
     # if reactive? && [:added, :removed].include?(event)
     #   self.object_tracker.queue_update
     #   ObjectTracker.process_queue
     # end
 
 
-    # puts "Register: #{event} on #{self.inspect}"   
+    # puts "Register: #{event} on #{self.inspect}"
     event = event.to_sym
-    
+
     new_listener = Listener.new(self, event, scope_provider, block)
-    
+
     @listeners ||= {}
     @listeners[event] ||= []
     @listeners[event] << new_listener
 
     first = @listeners[event].size == 1
-    
+
     # 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
@@ -132,7 +132,7 @@ module Events
 
     return new_listener
   end
-  
+
   def event_chain
     @event_chain ||= EventChain.new(self)
   end
@@ -146,9 +146,9 @@ module Events
   # a listener
   def remove_listener(event, listener)
     event = event.to_sym
-    
+
     raise "Unable to delete #{event} from #{self.inspect}" unless @listeners && @listeners[event]
-    
+
     # if @listeners && @listeners[event]
       @listeners[event].delete(listener)
 
@@ -169,14 +169,14 @@ module Events
       end
     # end
   end
-    
+
   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
-    
+
     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
@@ -187,7 +187,7 @@ module Events
         # 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}"   
+        # 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
@@ -196,19 +196,19 @@ module Events
 
     nil
   end
-  
-  # Takes a block, which passes in 
+
+  # Takes a block, which passes in
   def trigger_by_scope!(event, *args, &block)
     trigger!(event, block, *args)
   end
-  
+
   # Takes an event and a list of method names, and triggers the event for each listener
   # coming off of those methods.
   def trigger_for_methods!(event, *method_names)
     trigger_by_scope!(event, [], nil) do |scope|
       if scope
         method_name = scope.first
-      
+
         method_names.include?(method_name)
       else
         false
@@ -216,4 +216,4 @@ module Events
     end
   end
 
-end
+end

data/lib/volt/reactive/object_tracker.rb

@@ -3,50 +3,50 @@ class ObjectTracker
   @@queue = {}
   @@cache_enabled = false
   @@cache_version = 0
-  
+
   def self.cache_enabled
     @@cache_enabled
   end
-  
+
   def self.enable_cache
     clear_cache
     @@cache_enabled = true
   end
-  
+
   def self.disable_cache
     @@cache_enabled = false
   end
-  
+
   def self.cache_version
     @@cache_version
   end
-  
+
   def self.clear_cache
     @@cache_version = (@@cache_version || 0) + 1
   end
-  
+
   def initialize(main_object)
     @main_object = main_object
     @enabled = false
   end
-  
+
   def self.queue
     @@queue
   end
-  
+
   def queue_update
     # puts "Queue: #{@main_object.inspect}"
     @@queue[self] = true
   end
-  
+
   # Run through the queue and update the followers for each
   def self.process_queue
     return if @@queue.size == 0
     # puts "PROCESS QUEUE: #{@@queue.size}"
     queue = @@queue
 
-    # puts "Update Followers #{@@queue.size}" 
-    
+    # puts "Update Followers #{@@queue.size}"
+
     # Clear before running incase someone adds during
     @@queue = {}
     # self.enable_cache
@@ -54,19 +54,19 @@ class ObjectTracker
     queue.each_pair do |object_tracker,val|
       object_tracker.update_followers
     end
-    
+
     # self.disable_cache
-    
+
     # puts "UPDATED FOLLOWERS"
   end
-  
+
   def enable!
     unless @enabled
       @enabled = true
       queue_update
     end
   end
-  
+
   def disable!
     remove_followers
     @@queue.delete(self)
@@ -76,12 +76,12 @@ class ObjectTracker
   def update_followers
     if @enabled
       current_obj = @main_object.cur#(true)
-      
+
       # puts "UPDATE ON #{current_obj.inspect}"
-      
+
       if !@cached_current_obj || current_obj.object_id != @cached_current_obj.object_id
         remove_followers
-  
+
         # Add to current
         should_attach = current_obj.respond_to?(:on)
         if should_attach
@@ -93,15 +93,15 @@ class ObjectTracker
     else
     end
   end
-  
+
   # Remove follower
   def remove_followers
     # Remove from previous
     if @cached_current_obj
       @current_obj_chain_listener.remove
       @current_obj_chain_listener = nil
-      
+
       @cached_current_obj = nil
     end
   end
-end
+end

data/lib/volt/reactive/object_tracking.rb

@@ -1,7 +1,7 @@
 # Provides methods for objects that store reactive value's to trigger
 module ObjectTracking
   def __setup_tracking(key, value)
-    if value.reactive?      
+    if value.reactive?
       # TODO: We should build this in so it fires just for the current index.
       # Currently this is a big performance hit.
       chain_listener = event_chain.add_object(value.reactive_manager) do |event, *args|
@@ -11,4 +11,4 @@ module ObjectTracking
       @reactive_element_listeners[key] = chain_listener
     end
   end
-end
+end