volt 0.6.5 → 0.7.0

data/lib/volt/reactive/reactive_array.rb

@@ -3,20 +3,20 @@ require 'volt/reactive/object_tracking'
 class ReactiveArray# < Array
   include ReactiveTags
   include ObjectTracking
-  
+
   def initialize(array=[])
     @array = array
   end
-  
+
   # Forward any missing methods to the array
   def method_missing(method_name, *args, &block)
     @array.send(method_name, *args, &block)
   end
-  
+
   def ==(*args)
     @array.==(*args)
   end
-  
+
   tag_method(:each) do
     destructive!
   end
@@ -24,22 +24,22 @@ class ReactiveArray# < Array
   def each(&block)
     @array.each(&block)
   end
-  
+
   tag_method(:[]=) do
     pass_reactive!
   end
-  
+
   # alias :__old_assign :[]=
-  def []=(index, value)  
-    index_val = index.cur  
+  def []=(index, value)
+    index_val = index.cur
     # Clean old value
     __clear_element(index)
-    
+
     @array[index.cur] = value
-    
+
     # Track new value
     __track_element(index, value)
-    
+
     # Also track the index if its reactive
     if index.reactive?
       # TODO: Need to clean this up when the index changes
@@ -47,38 +47,38 @@ class ReactiveArray# < Array
         trigger_for_index!(event, index.cur)
       end
     end
-    
+
     # Trigger changed
     trigger_for_index!('changed', index_val)
   end
-  
+
   tag_method(:delete_at) do
     destructive!
   end
   # alias :__old_delete_at :delete_at
   def delete_at(index)
     index_val = index.cur
-    
+
     __clear_element(index)
-    
+
     model = @array.delete_at(index_val)
-    
+
     trigger_on_direct_listeners!('removed', index_val)
-    
-    # Trigger a changed event for each element in the zone where the 
+
+    # Trigger a changed event for each element in the zone where the
     # lookup would change
     index.upto(self.size+1) do |position|
       trigger_for_index!('changed', position)
     end
-    
+
     trigger_size_change!
-    
+
     @persistor.removed(model) if @persistor
-    
+
     return model
   end
-  
-  
+
+
   # Delete is implemented as part of delete_at
   tag_method(:delete) do
     destructive!
@@ -86,7 +86,7 @@ class ReactiveArray# < Array
   def delete(val)
     self.delete_at(@array.index(val))
   end
-  
+
   # Removes all items in the array model.
   tag_method(:clear) do
     destructive!
@@ -102,35 +102,35 @@ class ReactiveArray# < Array
   # alias :__old_append :<<
   def <<(value)
     result = (@array << value)
-    
+
     # Track new value
     __track_element(self.size-1, value)
-    
+
     trigger_for_index!('changed', self.size-1)
     trigger_on_direct_listeners!('added', self.size-1)
-    
+
     trigger_size_change!
 
     return result
   end
-  
-  
+
+
   def +(array)
     old_size = self.size
-     
+
     # TODO: += is funky here, might need to make a .plus! method
     result = ReactiveArray.new(@array.dup + array)
-    
+
     old_size.upto(result.size-1) do |index|
       trigger_for_index!('changed', index)
       trigger_on_direct_listeners!('added', old_size + index)
     end
-    
+
     trigger_size_change!
-    
+
     return result
   end
-  
+
   tag_method(:insert) do
     destructive!
   end
@@ -145,37 +145,37 @@ class ReactiveArray# < Array
     objects.size.times do |count|
       trigger_on_direct_listeners!('added', index+count)
     end
-    
+
     trigger_size_change!
-    
+
     return result
   end
-  
+
   def trigger_on_direct_listeners!(event, *args)
     trigger_by_scope!(event, *args) do |scope|
       # Only if it is bound directly to us.  Don't pass
       # down the chain
       !scope || scope[0] == nil
     end
-    
+
   end
-  
+
   def trigger_size_change!
     trigger_by_scope!('changed') do |scope|
       # method_name, *args, block = scope
       method_name, args, block = split_scope(scope)
-      
+
       result = case method_name && method_name.to_sym
       when :size, :length
         true
       else
         false
       end
-      
+
       result
     end
   end
-  
+
   # TODO: This is an opal work around.  Currently there is a bug with destructuring
   # method_name, *args, block = scope
   def split_scope(scope)
@@ -183,18 +183,18 @@ class ReactiveArray# < Array
       scope = scope.dup
       method_name = scope.shift
       block = scope.pop
-    
+
       return method_name, scope, block
     else
       return nil,[],nil
     end
   end
-  
-  # Trigger the changed event to any values fetched either through the 
-  # lookup ([]), #last, or any fetched through the array its self. (sum, max, etc...)   
+
+  # Trigger the changed event to any values fetched either through the
+  # lookup ([]), #last, or any fetched through the array its self. (sum, max, etc...)
   # On an array, when an element is added or removed, we need to trigger change
   # events on each method that does the following:
-  # 1. uses the whole array (max, sum, etc...) 
+  # 1. uses the whole array (max, sum, etc...)
   # 2. accesses this specific element - array[index]
   # 3. accesses an element via a method (first, last)
   def trigger_for_index!(event_name, index, *passed_args)
@@ -202,7 +202,7 @@ class ReactiveArray# < Array
       # method_name, *args, block = scope
       method_name, args, block = split_scope(scope)
       # puts "SCOPE CHECK: TFI: #{method_name.inspect} - #{args.inspect} on #{self.inspect}"
-      
+
       result = case method_name
       when nil
         # no method name means the event was bound directly, we don't
@@ -211,7 +211,7 @@ class ReactiveArray# < Array
       when :[]
         # Extract the current index if its reactive
         arg_index = args[0].cur
-        
+
         # TODO: we could handle negative indicies better
         arg_index == index.cur || arg_index < 0
       when :last
@@ -224,17 +224,17 @@ class ReactiveArray# < Array
       else
         true
       end
-      
+
       result
     end
-  end  
-  
+  end
+
   def inspect
     "#<#{self.class.to_s} #{@array.inspect}>"
   end
-  
+
   private
-  
+
     def __clear_element(index)
       # Cleanup any tracking on an index
       if @reactive_element_listeners && self[index].reactive?
@@ -242,11 +242,11 @@ class ReactiveArray# < Array
         @reactive_element_listeners.delete(index)
       end
     end
-  
+
     def __track_element(index, value)
       __setup_tracking(index, value) do |event, index, args|
         trigger_for_index!(event, index, *args)
       end
     end
-  
-end
+
+end

data/lib/volt/reactive/reactive_tags.rb

@@ -1,6 +1,6 @@
 require 'volt/reactive/destructive_methods'
 
-# ReactiveTags provide an easy way to specify how a class deals with 
+# ReactiveTags provide an easy way to specify how a class deals with
 # reactive events and method calls.als
 module ReactiveTags
   class MethodTags
@@ -9,40 +9,40 @@ module ReactiveTags
 
   class MethodTagger
     attr_reader :method_tags
-    
+
     def initialize
       @method_tags = MethodTags.new
     end
-    
+
     def destructive!(&block)
       @method_tags.destructive = block || true
     end
-    
+
     def pass_reactive!
       @method_tags.pass_reactive = true
     end
   end
-  
-  module ClassMethods  
+
+  module ClassMethods
     def tag_method(method_name, &block)
       tagger = MethodTagger.new
-    
+
       tagger.instance_eval(&block)
-    
+
       @reactive_method_tags ||= {}
       @reactive_method_tags[method_name.to_sym] = tagger.method_tags
-      
+
       # Track a destructive method
       if tagger.method_tags.destructive
         DestructiveMethods.add_method(method_name)
       end
     end
-    
+
     def tag_all_methods(&block)
       tagger = MethodTagger.new
-      
+
       tagger.instance_eval(&block)
-    
+
       @reactive_method_tags ||= {}
       @reactive_method_tags[:__all_methods] = tagger.method_tags
     end
@@ -53,19 +53,19 @@ module ReactiveTags
     # Check to make sure we haven't gone above a class that has included
     # ReactiveTags
     return nil if !klass || !klass.method_defined?(:reactive_method_tag)
-    
+
     tags = klass.instance_variable_get('@reactive_method_tags')
 
     if tags && (tag = tags[method_name.to_sym]) && (tag = tag.send(tag_name))
       return tag
     end
-    
+
     return self.reactive_method_tag(method_name, tag_name, klass.superclass)
   end
-  
+
 
   def self.included(base)
     base.send(:extend, ClassMethods)
     base.send(:include, Events)
   end
-end
+end