volt 0.2.3

data/lib/volt/reactive/object_tracker.rb

@@ -0,0 +1,99 @@
+OBJECT_TRACKER_DEBUG = false
+
+class ObjectTracker
+  @@queue = {}
+  @@cache_enabled = false
+  @@cache_version = 0
+  
+  def self.cache_enabled
+    @@cache_enabled
+  end
+  
+  def self.cache_version
+    @@cache_version
+  end
+  
+  def self.clear_cache
+    @@cache_version = (@@cache_version || 0) + 1
+  end
+  
+  def initialize(main_object)
+    # puts "NEW OBJECT TRACKER FOR: #{main_object.inspect}"
+    @main_object = main_object
+    @enabled = false
+  end
+  
+  def self.queue
+    @@queue
+  end
+  
+  def queue_update
+    puts "QUEUE UPDATE" if OBJECT_TRACKER_DEBUG
+    @@queue[self] = true
+  end
+  
+  # Run through the queue and update the followers for each
+  def self.process_queue
+    # puts "PROCESS QUEUE: #{@@queue.size}"
+    puts "Process #{@@queue.size} items" if OBJECT_TRACKER_DEBUG
+    # TODO: Doing a full dup here is expensive?
+    queue = @@queue.dup
+    
+    # Clear before running incase someone adds during
+    @@queue = {}
+
+    @@cache_enabled = true
+    self.clear_cache
+
+    queue.each_pair do |object_tracker,val|
+      object_tracker.update_followers
+    end
+    
+    @@cache_enabled = false
+    
+  end
+  
+  def enable!
+    unless @enabled
+      puts "Enable OBJ Tracker" if OBJECT_TRACKER_DEBUG
+      @enabled = true
+      queue_update
+    end
+  end
+  
+  def disable!
+    puts "Disable OBJ Tracker" if OBJECT_TRACKER_DEBUG
+    remove_followers
+    @@queue.delete(self)
+    @enabled = false
+  end
+
+  def update_followers
+    if @enabled
+      puts "UPDATE" if OBJECT_TRACKER_DEBUG
+      current_obj = @main_object.cur#(true)
+      
+      # puts "UPDATE ON #{current_obj.inspect}"
+    
+      remove_followers
+  
+      # Add to current
+      should_attach = current_obj.respond_to?(:on)
+      if should_attach
+        current_obj.add_event_follower(@main_object)
+        @cached_current_obj = current_obj
+      end
+    else
+      puts "DISABLED, no update" if OBJECT_TRACKER_DEBUG
+    end
+  end
+  
+  # Remove follower
+  def remove_followers
+    # Remove from previous
+    if @cached_current_obj
+      @cached_current_obj.remove_event_follower(@main_object)
+      @cached_current_obj = nil
+    end
+  end
+end

data/lib/volt/reactive/object_tracking.rb

@@ -0,0 +1,15 @@
+# Provides methods for objects that store reactive value's to trigger
+module ObjectTracking
+  def __setup_tracking(key, value)
+    if value.reactive?      
+      puts "Value: #{value.inspect} - #{key}"
+      # 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|
+        yield(event, key, args)
+      end
+      @reactive_element_listeners ||= {}
+      @reactive_element_listeners[key] = chain_listener
+    end
+  end
+end

data/lib/volt/reactive/reactive_array.rb

@@ -0,0 +1,222 @@
+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(:[]=) do
+    destructive!
+    pass_reactive!
+  end
+  
+  # alias :__old_assign :[]=
+  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
+      event_chain.add_object(index.reactive_manager) do |event, *args|
+        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)
+    
+    @array.delete_at(index_val)
+    
+    trigger_on_direct_listeners!('removed', index_val)
+    
+    # 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!
+  end
+  
+
+  tag_method(:<<) do
+    destructive!
+    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_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
+  # alias :__old_insert :insert
+  def insert(*args)
+    old_size = self.size
+    result = @array.insert(*args)
+
+    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
+  
+  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
+    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?
+        @reactive_element_listeners[index].remove
+        @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

data/lib/volt/reactive/reactive_tags.rb

@@ -0,0 +1,64 @@
+# ReactiveTags provide an easy way to specify how a class deals with 
+# reactive events and method calls.als
+module ReactiveTags
+  class MethodTags
+    attr_accessor :destructive, :pass_reactive, :reacts_with
+  end
+
+  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  
+    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
+    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
+  end
+
+  # Returns a reference to the tags on a method
+  def reactive_method_tag(method_name, tag_name, klass=self.class)
+    # 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

data/lib/volt/reactive/reactive_value.rb

@@ -0,0 +1,368 @@
+require 'volt/reactive/events'
+require 'volt/reactive/reactive_tags'
+require 'volt/reactive/string_extensions'
+require 'volt/reactive/array_extensions'
+require 'volt/reactive/reactive_array'
+require 'volt/reactive/object_tracker'
+
+class Object
+  def cur
+    self
+  end
+  
+  def reactive?
+    false
+  end
+end
+
+class ReactiveValue < BasicObject
+  # methods on ReactiveValues:
+  # reactive?, cur, with, on, data, trigger!
+  # - everything else is forwarded to the ReactiveManager
+  
+  # Methods we should skip wrapping the results in
+  # We skip .hash because in uniq it has .to_int called on it, which needs to
+  # return a Fixnum instance.
+  # :hash -   needs something where .to_int can be called on it and it will
+  #           return an int
+  # :methods- needs to return a straight up array to work with irb tab completion
+  # :eql?   - needed for .uniq to work correctly
+  # :to_ary - in some places ruby expects to get an array back from this method
+  SKIP_METHODS = [:hash, :methods, :eql?, :respond_to?, :respond_to_missing?, :to_ary, :to_int]#, :instance_of?, :kind_of?, :to_s, :to_str]
+
+  def initialize(getter, setter=nil, scope=nil)
+    @reactive_manager = ::ReactiveManager.new(getter, setter, scope)
+  end
+  
+  def reactive?
+    true
+  end
+  
+  # Proxy methods to the ReactiveManager.  We want to have as few
+  # as possible methods on reactive values, so all other methods
+  # are forwarded to the object the reactive value points to.
+  [:cur, :cur=, :on, :trigger!].each do |method_name|
+    define_method(method_name) do |*args, &block|
+      @reactive_manager.send(method_name, *args, &block)
+    end
+  end
+  
+  def reactive_manager
+    @reactive_manager
+  end
+  alias_method :rm, :reactive_manager  
+  
+  def check_tag(method_name, tag_name)
+    current_obj = cur # TODO: should be cached somehow
+    
+    if current_obj.respond_to?(:reactive_method_tag)
+      tag = current_obj.reactive_method_tag(method_name, tag_name)
+      
+      unless tag
+        # Get the tag from the all methods if its not directly specified
+        tag = current_obj.reactive_method_tag(:__all_methods, tag_name)
+      end
+      
+      # Evaluate now if its a proc
+      tag = tag.call(method_name) if tag.class == ::Proc
+      
+      return tag
+    end
+    
+    return nil
+  end
+  
+  def puts(*args)
+    ::Object.send(:puts, *args)
+  end
+  
+  def method_missing(method_name, *args, &block)
+    # Unroll send into a direct call
+    if method_name == :send
+      method_name, *args = args
+    end
+    
+    # Check to see if the method we're calling wants to receive reactive values.
+    pass_reactive = check_tag(method_name, :pass_reactive)
+
+    # For some methods, we pass directly to the current object.  This
+    # helps ReactiveValue's be well behaved ruby citizens.
+    # Also skip if this is a destructive method
+    if SKIP_METHODS.include?(method_name) || check_tag(method_name, :destructive)# || (method_name[0] =~ /[a-zA-Z]/ && !cur.is_a?(::Exception))
+      pass_args = pass_reactive ? args : args.map{|v| v.cur }
+      return cur.__send__(method_name, *pass_args, &block)
+    end
+    
+    @block_reactives = []
+    result = @reactive_manager.with_and_options(args, pass_reactive) do |val, in_args|
+      # When a method is called with a block, we pass in our own block that wraps the
+      # block passed in.  This way we can pass in any arguments as reactive and track
+      # the return values.
+      new_block = block
+      # index_cache = []
+      # index = 0
+      # 
+      # if false && new_block
+      #   new_block = ::Proc.new do |*block_args|
+      #     res = block.call(*block_args.map {|v| ::ReactiveValue.new(v) })
+      #     
+      #     result.rm.remove_parent!(index_cache[index]) if index_cache[index]
+      #     puts "index: #{index}"
+      #     index_cache[index] = res
+      # 
+      #     # @block_reactives << res
+      #     result.rm.add_parent!(res)
+      #     # puts "Parent Size: #{result.rm.parents.size}"
+      #     
+      #     index += 1
+      #     
+      #     res.cur
+      #   end
+      # end
+      
+      val.__send__(method_name, *in_args, &new_block)
+    end
+    
+    manager = result.reactive_manager
+    
+    setup_setter(manager, method_name, args)
+    
+    manager.set_scope!([method_name, *args, block])
+    
+    # result = result.with(block_reactives) if block
+    
+    return result
+  end
+  
+  def setup_setter(manager, method_name, args)
+    # See if we can automatically create a setter.  If we are fetching a
+    # value via a read, we can probably reassign it with .name=
+    if args.size == 0
+      # TODO: At the moment we are defining a setter on all "reads", this
+      # probably has some performance implications
+      manager.setter! do |val|
+        # Call setter
+        self.cur.send(:"#{method_name}=", val)
+      end
+    elsif args.size == 1 && method_name == :[]
+      manager.setter! do |val|
+        # Call an array setter
+        self.cur.send(:"#{method_name}=", args[0], val)
+      end      
+    end
+  end
+  # 
+  # def respond_to?(name, include_private=false)
+  #   [:event_added, :event_removed].include?(name) || super
+  # end
+  
+  def respond_to_missing?(name, include_private=false)
+    cur.respond_to?(name)
+  end
+  
+  def with(*args, &block)
+    return @reactive_manager.with(*args, &block)
+  end
+  
+  def inspect
+    "@#{cur.inspect}"
+  end
+  
+  def pretty_inspect
+    inspect
+  end
+  
+  # Not 100% sure why, but we need to define this directly, it doesn't call
+  # on method missing
+  def ==(val)
+    method_missing(:==, val)
+  end
+
+  # TODO: this is broke in opal
+  def !
+    method_missing(:!)
+  end
+  
+  def to_s
+    cur.to_s
+  end
+  
+  def coerce(other)
+    if other.reactive?
+      return [other, self]
+    else
+      wrapped_object = ::ReactiveValue.new(other, [])
+      return [wrapped_object, self]
+    end
+  end
+end
+
+class ReactiveManager
+  include ::Events
+  
+  attr_reader :scope, :parents
+  
+  # When created, ReactiveValue's get a getter (a proc)
+  def initialize(getter, setter=nil, scope=nil)
+    @getter = getter
+    @setter = setter
+    @scope = scope
+    
+    @parents = []
+    
+    object_tracker.enable!
+  end
+  
+  def reactive?
+    true
+  end
+  
+  def inspect
+    "@<#{self.class.to_s}:#{reactive_object_id} #{cur.inspect}>"
+  end
+  
+  def reactive_object_id
+    @reactive_object_id ||= rand(100000)
+  end
+  
+  
+  # def event_added(event, scope, first)
+  #   # When the first event is registered, we need to start listening on our current object
+  #   # for it to publish events.
+  #   # object_tracker.enable! if first
+  # end
+  # 
+  # def event_removed(event, last)
+  #   # If no one is listening on the reactive value, then we don't need to listen on our
+  #   # current object for events, because no one cares.
+  #   # Note: when we're tracking the current object, it will have one registered changed 
+  #   # event.
+  #   # update_current_object(true) if last && !has_non_tracking_listeners?
+  #   # object_tracker.disable! if @listeners.size == 0
+  # end
+  
+  def object_tracker
+    @object_tracker ||= ::ObjectTracker.new(self)
+  end
+
+
+  # Fetch the current value
+  def cur
+    # if @cached_obj && ObjectTracker.cache_version == @cached_version
+    #   return @cached_obj
+    # end
+    
+    if @getter.class == ::Proc
+      # Get the current value, capture any errors
+      begin
+        result = @getter.call
+      rescue => e
+        result = e
+      end
+    else
+      # getter is just an object, return it
+      result = @getter
+    end
+    
+    if result.reactive?
+      # Unwrap any stored reactive values
+      result = result.cur
+    end
+    
+    # if ObjectTracker.cache_enabled
+      # @cached_obj = result
+      # @cached_version = ObjectTracker.cache_version
+    # end
+    
+    return result
+  end
+  
+  def cur=(val)
+    if @setter
+      @setter.call(val)
+    elsif @scope == nil
+      @getter = val
+      @setter = nil
+      
+      trigger!('changed')
+    else
+      raise "Value can not be updated"
+    end
+  end
+  
+  # With returns a new reactive value dependent on any arguments passed in.
+  # If a block is passed in, the getter is the block its self, which will
+  # be passed the .cur and the .cur of any reactive arguments.
+  def with(*args, &block)
+    return with_and_options(args, false, &block)
+  end
+  
+  def with_and_options(args, pass_reactive, &block)
+    getter = @getter
+    setter = @setter
+    scope = @scope
+     
+    if block
+      # If a block was passed in, the getter now becomes a proc that calls
+      # the passed in block with the right arguments.
+      getter = ::Proc.new do
+        # Unwrap arguments if the method doesn't want reactive values
+        pass_args = pass_reactive ? args : args.map{|v| v.cur }
+        
+        # TODO: Calling cur every time
+        current_val = self.cur
+        
+        if current_val.is_a?(Exception)
+          current_val
+        else
+          block.call(current_val, pass_args)
+        end
+      end
+      
+      # TODO: Make this work with custom setters
+      setter = nil
+
+      # Scope also gets set to nil, because now we should always retrigger this
+      # method because we don't know enough about what methods its calling.
+      scope = nil
+    end
+    
+    new_val = ReactiveValue.new(getter, setter, scope)
+    
+    # Add the ReactiveValue we're building from
+    new_val.reactive_manager.add_parent!(self)
+    
+    # Add any reactive arguments as parents
+    args.select(&:reactive?).each do |arg|
+      new_val.reactive_manager.add_parent!(arg.reactive_manager)
+    end
+    
+    return new_val
+  end
+  
+  def add_parent!(parent)
+    @parents << parent
+    event_chain.add_object(parent)
+  end
+  
+  def remove_parent!(parent)
+    @parents.delete(parent)
+    event_chain.remove_object(parent)
+  end
+  
+  def set_scope!(new_scope)
+    @scope = new_scope
+    
+    self
+  end
+  
+  def set_scope(new_scope)
+    dup.scope!(new_scope)
+  end
+  
+  # Sets the setter
+  def setter!(setter=nil, &block)
+    @setter = setter || block
+  end
+
+end