volt 0.7.23 → 0.8.0

data/lib/volt/reactive/computation.rb

@@ -0,0 +1,131 @@
+class Computation
+  @@current = nil
+  @@flush_queue = []
+
+
+  def self.current=(val)
+    @@current = val
+  end
+
+  def self.current
+    @@current
+  end
+
+  def initialize(computation)
+    @computation = computation
+    @invalidations = []
+  end
+
+  # Runs the computation
+  def compute!
+    @invalidated = false
+
+    unless @stopped
+
+      @computing = true
+      run_in do
+        @computation.call
+      end
+      @computing = false
+    end
+  end
+
+  def on_invalidate(&callback)
+    if @invalidated
+      # Call invalidate now, since its already invalidated
+      Computation.run_without_tracking do
+        callback.call
+      end
+    else
+      # Store the invalidation
+      @invalidations << callback
+    end
+  end
+
+  # Calling invalidate removes the computation from all of
+  # its dependencies.  This keeps its dependencies from
+  # invalidating it again.
+  def invalidate!
+    unless @invalidated
+      @invalidated = true
+
+      if !@stopped && !@computing
+        @@flush_queue << self
+
+        # If we are in the browser, we queue a flush for the next tick
+        if Volt.in_browser?
+          self.class.queue_flush!
+        end
+      end
+
+      invalidations = @invalidations
+      @invalidations = []
+
+      invalidations.each do |invalidation|
+        invalidation.call
+      end
+    end
+  end
+
+  # Stop re-run of the computations
+  def stop
+    unless @stopped
+      @stopped = true
+      invalidate!
+    end
+  end
+
+  # Runs in this computation as the current computation, returns the computation
+  def run_in
+    previous = Computation.current
+    Computation.current = self
+    yield
+    Computation.current = previous
+
+    return self
+  end
+
+  def self.run_without_tracking
+    previous = Computation.current
+    Computation.current = nil
+    return_value = yield
+    Computation.current = previous
+
+    return return_value
+  end
+
+
+  def self.flush!
+    raise "Can't flush while in a flush" if @flushing
+
+    @flushing = true
+    # clear any timers
+    @timer = nil
+
+    computations = @@flush_queue
+    @@flush_queue = []
+
+    computations.each do |computation|
+      computation.compute!
+    end
+
+    @flushing = false
+  end
+
+  def self.queue_flush!
+    if !@timer
+      # Flush once everything else has finished running
+      @timer = `setImmediate(function() { self['$flush!'](); });`
+    end
+  end
+end
+
+
+class Proc
+  def watch!
+    return Computation.new(self).run_in do
+      # run self
+      self.call
+    end
+  end
+end

data/lib/volt/reactive/dependency.rb

@@ -0,0 +1,71 @@
+# Temp until https://github.com/opal/opal/pull/596
+require 'set'
+
+class Set
+  def delete(o)
+    @hash.delete(o)
+  end
+
+  def delete?(o)
+    if include?(o)
+      delete(o)
+    else
+      nil
+    end
+  end
+
+  def delete_if
+    block_given? or return enum_for(__method__)
+    # @hash.delete_if should be faster, but using it breaks the order
+    # of enumeration in subclasses.
+    select { |o| yield o }.each { |o| @hash.delete(o) }
+    self
+  end
+
+  def to_a
+    @hash.keys
+  end
+end
+
+class Dependency
+  def initialize
+    @dependencies = Set.new
+  end
+
+  def depend
+    # If there is no @dependencies, don't depend because it has been removed
+    return unless @dependencies
+
+    current = Computation.current
+    if current
+      added = @dependencies.add?(current)
+
+      if added
+        # puts "Added #{self.inspect} to #{current.inspect}"
+        current.on_invalidate do
+          # If @dependencies is nil, this Dependency has been removed
+          @dependencies.delete(current) if @dependencies
+        end
+      end
+    end
+  end
+
+  def changed!
+    deps = @dependencies
+
+    # If no deps, dependency has been removed
+    return unless deps
+
+    @dependencies = Set.new
+
+    deps.each do |dep|
+      dep.invalidate!
+    end
+  end
+
+  # Called when a dependency is no longer needed
+  def remove
+    changed!
+    @dependencies = nil
+  end
+end

data/lib/volt/reactive/eventable.rb

@@ -0,0 +1,82 @@
+class Listener
+  def initialize(klass, event, callback)
+    @klass = klass
+    @event = event
+    @callback = callback
+  end
+
+  def call(*args)
+    @callback.call(*args) unless @removed
+  end
+
+  def remove
+    @removed = true
+
+    @klass.remove_listener(@event, self)
+
+    # Make things easier on the GC
+    @klass = nil
+    @callback = nil
+  end
+
+  def inspect
+     "<Listener:#{object_id} event=#{@event}>"
+   end
+end
+
+module Eventable
+  def on(event, &callback)
+    event = event.to_sym
+    listener = Listener.new(self, event, callback)
+    @listeners ||= {}
+    @listeners[event] ||= []
+    @listeners[event] << listener
+
+    first_for_event = @listeners[event].size == 1
+    first = first_for_event && @listeners.size == 1
+
+    # Let the included class know that an event was registered. (if it cares)
+    if self.respond_to?(:event_added)
+      # call event added passing the event, the scope, and a boolean if it
+      # is the first time this event has been added.
+      self.event_added(event, first, first_for_event)
+    end
+
+    return listener
+  end
+
+  def trigger!(event, *args)
+    event = event.to_sym
+
+    return unless @listeners && @listeners[event]
+
+    # TODO: We have to dup here because one trigger might remove another
+    @listeners[event].dup.each do |listener|
+      # Call the event on each listener
+      listener.call(*args)
+    end
+  end
+
+  def remove_listener(event, listener)
+    event = event.to_sym
+
+    raise "Unable to delete #{event} from #{self.inspect}" unless @listeners && @listeners[event]
+
+    @listeners[event].delete(listener)
+
+    last_for_event = @listeners[event].size == 0
+
+    if last_for_event
+      # No registered listeners now on this event
+      @listeners.delete(event)
+    end
+
+    last = last_for_event && @listeners.size == 0
+
+    # Let the class we're included on know that we removed a listener (if it cares)
+    if self.respond_to?(:event_removed)
+      # Pass in the event and a boolean indicating if it is the last event
+      self.event_removed(event, last, last_for_event)
+    end
+  end
+end

data/lib/volt/reactive/hash_dependency.rb

@@ -0,0 +1,36 @@
+class HashDependency
+  def initialize
+    @hash_depedencies = {}
+  end
+
+  def depend(key)
+    ensure_key(key).depend
+  end
+
+  def changed!(key)
+    ensure_key(key).changed!
+  end
+
+  def delete(key)
+    # TODORW: should this .remove
+    dep = @hash_depedencies[key]
+
+    if dep
+      dep.changed!
+      dep.remove
+    end
+
+    @hash_depedencies.delete(key)
+  end
+
+  def changed_all!
+    @hash_depedencies.each_pair do |key,value|
+      value.changed!
+    end
+  end
+
+  private
+    def ensure_key(key)
+      @hash_depedencies[key] ||= Dependency.new
+    end
+end

data/lib/volt/{controllers → reactive}/reactive_accessors.rb

@@ -4,17 +4,18 @@ module ReactiveAccessors
     # Create a method to read a reactive value from an instance value.  If it
     # is not setup, create it so it can be updated through the reactive value
     # at a later point.
+    def __reactive_dependency_get(var_name)
+      value_dep = instance_variable_get(:"@__#{var_name}_dependency")
+      value_dep ||= instance_variable_set(:"@__#{var_name}_dependency", Dependency.new)
+    end
+
     def reactive_reader(*names)
       names.each do |name|
         var_name = :"@#{name}"
         define_method(name.to_sym) do
           value = instance_variable_get(var_name)
 
-          unless value
-            value = ReactiveValue.new(nil)
-
-            instance_variable_set(var_name, value)
-          end
+          self.class.__reactive_dependency_get(name).depend
 
           value
         end
@@ -25,13 +26,9 @@ module ReactiveAccessors
       names.each do |name|
         var_name = :"@#{name}"
         define_method(:"#{name}=") do |new_value|
-          value = instance_variable_get(var_name)
+          instance_variable_set(var_name, new_value)
 
-          if value
-            value.cur = new_value
-          else
-            instance_variable_set(var_name, ReactiveValue.new(value))
-          end
+          self.class.__reactive_dependency_get(name).changed!
         end
       end
     end

data/lib/volt/reactive/reactive_array.rb

@@ -1,12 +1,13 @@
-require 'volt/reactive/object_tracking'
-require 'volt/reactive/reactive_block'
+require 'volt/reactive/eventable'
 
 class ReactiveArray# < Array
-  include ReactiveTags
-  include ObjectTracking
+  include Eventable
 
   def initialize(array=[])
     @array = array
+    @array_deps = []
+    @size_dep = Dependency.new
+    @old_size = 0
   end
 
   # Forward any missing methods to the array
@@ -18,64 +19,74 @@ class ReactiveArray# < Array
     @array.==(*args)
   end
 
-  tag_method(:each) do
-    destructive!
-  end
   # At the moment, each just passes through.
   def each(&block)
     @array.each(&block)
   end
 
-  tag_method(:[]=) do
-    pass_reactive!
+  def count(&block)
+    if block
+      count = 0
+      size.times do |index|
+        if block.call(self[index]).true?
+          count += 1
+        end
+      end
+
+      return count
+    else
+      return size
+    end
   end
 
-  # alias :__old_assign :[]=
-  def []=(index, value)
-    index_val = index.cur
+  # TODO: Handle a range
+  def [](index)
+    # Handle a negative index
+    index = size + index if index < 0
 
-    if index_val < 0
-      # Handle a negative index
-      index_val = size + index_val
-    end
+    # Get or create the dependency
+    dep = (@array_deps[index] ||= Dependency.new)
 
-    # Clean old value
-    __clear_element(index)
+    # Track the dependency
+    dep.depend
 
-    @array[index.cur] = value
+    # Return the index
+    return @array[index]
+  end
 
-    # Track new value
-    __track_element(index, value)
+  def []=(index, value)
 
-    # Also track the index if its reactive
-    if index.reactive?
-      # TODO: Need to clean this up when the index changes
-      event_chain.add_object(index.reactive_manager) do |event, *args|
-        trigger_for_index!(event, index.cur)
-      end
-    end
+    # Assign the new value
+    @array[index] = value
 
-    # Trigger changed
-    trigger_for_index!('changed', index_val)
+    trigger_for_index!(index)
+
+    trigger_size_change!
   end
 
-  tag_method(:delete_at) do
-    destructive!
+  def size
+    @size_dep.depend
+
+    return @array.size
   end
-  # alias :__old_delete_at :delete_at
+  alias :length :size
+
   def delete_at(index)
-    index_val = index.cur
+    # Handle a negative index
+    index = size + index if index < 0
 
-    __clear_element(index)
+    model = @array.delete_at(index)
 
-    model = @array.delete_at(index_val)
+    # Remove the dependency for that cell, and #remove it
+    index_deps = @array_deps.delete_at(index)
+    index_deps.remove if index_deps
 
-    trigger_on_direct_listeners!('removed', index_val)
+    trigger_removed!(index)
 
     # Trigger a changed event for each element in the zone where the
-    # lookup would change
+    # delete would change
     index.upto(self.size+1) do |position|
-      trigger_for_index!('changed', position)
+      trigger_for_index!(position)
     end
 
     trigger_size_change!
@@ -86,35 +97,45 @@ class ReactiveArray# < Array
   end
 
 
-  # Delete is implemented as part of delete_at
-  tag_method(:delete) do
-    destructive!
-  end
   def delete(val)
-    self.delete_at(@array.index(val))
+    index = @array.index(val)
+    if index
+      self.delete_at(index)
+    else
+      # Sometimes the model isn't loaded at the right state yet, so we
+      # just remove it from the persistor
+      @persistor.removed(val) if @persistor
+    end
   end
 
-  # Removes all items in the array model.
-  tag_method(:clear) do
-    destructive!
-  end
   def clear
+    old_size = @array.size
+
+    deps = @array_deps
+    @array_deps = []
+
+    # Trigger remove for each cell
+    old_size.times do |index|
+      trigger_removed!(old_size - index - 1)
+    end
+
+    # Trigger on each cell since we are clearing out the array
+    if deps
+      deps.each do |dep|
+        dep.changed! if dep
+      end
+    end
+
+    # clear the array
     @array = []
-    trigger!('changed')
   end
 
-  tag_method(:<<) do
-    pass_reactive!
-  end
   # 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_for_index!(self.size-1)
+    trigger_added!(self.size-1)
     trigger_size_change!
 
     return result
@@ -122,6 +143,7 @@ class ReactiveArray# < Array
 
 
   def +(array)
+    raise "not implemented yet"
     old_size = self.size
 
     # TODO: += is funky here, might need to make a .plus! method
@@ -129,7 +151,7 @@ class ReactiveArray# < Array
 
     old_size.upto(result.size-1) do |index|
       trigger_for_index!('changed', index)
-      trigger_on_direct_listeners!('added', old_size + index)
+      trigger_added!(old_size + index)
     end
 
     trigger_size_change!
@@ -137,19 +159,16 @@ class ReactiveArray# < Array
     return result
   end
 
-  tag_method(:insert) do
-    destructive!
-  end
   def insert(index, *objects)
     result = @array.insert(index, *objects)
 
     # All objects from index to the end have "changed"
-    index.upto(result.size-1) do |idx|
-      trigger_for_index!('changed', idx)
+    index.upto(result.size) do |index|
+      trigger_for_index!(index)
     end
 
     objects.size.times do |count|
-      trigger_on_direct_listeners!('added', index+count)
+      trigger_added!(index+count)
     end
 
     trigger_size_change!
@@ -157,150 +176,38 @@ class ReactiveArray# < Array
     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)
-    if scope
-      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...)
-  # 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...)
-  # 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)
-    self.trigger_by_scope!(event_name, *passed_args) do |scope|
-      # method_name, *args, block = scope
-      method_name, args, block = split_scope(scope)
-
-      result = case method_name
-      when nil
-        # no method name means the event was bound directly, we don't
-        # want to trigger changed on the array its self.
-        false
-      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
-        index.cur == self.size-1
-      when :first
-        index.cur == 0
-      when :size, :length
-        # Size does not depend on the contents of the cells
-        false
-      else
-        true
-      end
-
-      result = false if method_name == :reject
-
-      result
-    end
-  end
 
   def inspect
     "#<#{self.class.to_s}:#{object_id} #{@array.inspect}>"
   end
 
-  # tag_method(:count) do
-  #   destructive!
-  # end
-  def count(*args, &block)
-    # puts "GET COUNT"
-    if block
-      run_block = Proc.new do |source|
-        count = 0
-        source.cur.size.times do |index|
-          val = source[index]
-          result = block.call(val).cur
-          if result == true
-            count += 1
-          end
-        end
 
-        count
+  private
+    # Check to see if the size has changed, trigger a change on size if it has
+    def trigger_size_change!
+      new_size = @array.size
+      if new_size != @old_size
+        @old_size = new_size
+        @size_dep.changed!
       end
-
-      return ReactiveBlock.new(self, block, run_block)
-    else
-      @array.count(*args)
     end
-  end
 
-  def reject(*args, &block)
-    if block
-      run_block = Proc.new do |source|
-        puts "RUN REJECT"
-        new_array = []
-        source.cur.size.times do |index|
-          val = source[index]
-          result = block.call(val).cur
-          if result != true
-            new_array << val.cur
-          end
-        end
+    def trigger_for_index!(index)
+      # Trigger a change for the cell
+      dep = @array_deps[index]
 
-        ReactiveArray.new(new_array)
-      end
-
-      return ReactiveBlock.new(self, block, run_block)
-    else
-      @array.count
+      dep.changed! if dep
     end
-  end
 
-  private
 
-    def __clear_element(index)
-      # Cleanup any tracking on an index
-      if @reactive_element_listeners && self[index].reactive?
-        @reactive_element_listeners[index].remove
-        @reactive_element_listeners.delete(index)
-      end
+    def trigger_added!(index)
+      trigger!('added', index)
     end
 
-    def __track_element(index, value)
-      __setup_tracking(index, value) do |event, index, args|
-        trigger_for_index!(event, index, *args)
-      end
+    def trigger_removed!(index)
+      trigger!('removed', index)
     end
 
+
+
 end