volt 0.7.23 → 0.8.0

data/lib/volt/extra_core/time.rb

@@ -1,16 +0,0 @@
-class Temp1
-  include Events
-
-  attr_accessor :seconds
-  def initialize
-    @seconds = ReactiveValue.new(nil)
-  end
-
-  def seconds=(val)
-    @seconds.cur = val
-  end
-
-  def live_seconds
-    @seconds
-  end
-end

data/lib/volt/page/draw_cycle.rb

@@ -1,31 +0,0 @@
-# The draw cycle is responsible for queueing redraws until all of the events have
-# fired.  Once that is done, everything will be redrawn.  This prevents bindings
-# from being drawn multiple times before all events have propigated.
-class DrawCycle
-  def initialize
-    @queue = {}
-    @timer = nil
-  end
-
-  def queue(binding)
-    @queue[binding] = true
-
-    unless @timer
-      # Flush once everything else has finished running
-      @timer = `setTimeout(function() { self.$flush(); }, 0);`
-    end
-  end
-
-  def flush
-    @timer = nil
-
-    work_queue = @queue
-    @queue = {}
-
-    work_queue.each_pair do |binding,_|
-      # Call the update if queued
-      binding.update
-    end
-
-  end
-end

data/lib/volt/page/memory_test.rb

@@ -1,26 +0,0 @@
-require 'opal'
-require 'volt/models'
-
-class Test
-  def self.test1
-    a = ReactiveValue.new(1)
-    listener = a.on('changed') { puts "CHANGED" }
-    a.cur = 5
-    listener.remove
-
-    ObjectTracker.process_queue
-  end
-
-  def self.test
-    a = ReactiveValue.new(Model.new)
-    a._cool = [1,2,3]
-
-    listener = a._cool.on('added') { puts "ADDED" }
-    a._cool << 4
-    puts a._cool[3]
-
-    listener.remove
-
-    ObjectTracker.process_queue
-  end
-end

data/lib/volt/page/reactive_template.rb

@@ -1,32 +0,0 @@
-class ReactiveTemplate
-  include Events
-
-  def initialize(page, context, template_path)
-    @template_path = template_path
-    @target = AttributeTarget.new(nil, nil, self)
-    @template = TemplateRenderer.new(page, @target, context, "main", template_path)
-
-  end
-
-  def reactive?
-    true
-  end
-
-  # Render the template and get the current value
-  def cur
-    @target.to_html
-  end
-
-  def update
-    trigger!('changed')
-  end
-
-  def remove
-    @template.remove
-
-    @template = nil
-    @target = nil
-    @template_path = nil
-  end
-
-end

data/lib/volt/reactive/array_extensions.rb

@@ -1,12 +0,0 @@
-class Array
-  alias :__old_plus :+
-
-  def +(val)
-    result = __old_plus(val.cur)
-    if val.reactive? && !result.reactive?
-      result = ReactiveValue.new(result)
-    end
-
-    return result
-  end
-end

data/lib/volt/reactive/destructive_methods.rb

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

@@ -1,125 +0,0 @@
-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
-    if @removed
-      puts "event chain already removed"
-      return
-    end
-
-    @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;`
-      `console.log('del chain listeners: ', window.chain_listeners)`
-    end
-  end
-end
-
-class EventChain
-  def initialize(main_object)
-    @event_chain = {}
-    @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|
-      if (callback = chain_listener.callback)
-        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
-        # 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)
-    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
-      # TODO: The if shouldn't be needed, but sometimes we get nil for some reason?
-      listener.remove if listener
-    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
-        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
-    end
-  end
-end

data/lib/volt/reactive/events.rb

@@ -1,216 +0,0 @@
-require 'volt/reactive/event_chain'
-
-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, :klass
-
-  def initialize(klass, event, scope_provider, callback)
-    @klass = klass
-    @event = event
-    @scope_provider = scope_provider
-    @callback = callback
-
-    if DEBUG && RUBY_PLATFORM == 'opal'
-      # 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)
-    if @removed
-      # puts "Triggered on a removed event: #{@event}"
-      return
-    end
-
-    if @klass.reactive?
-      # Update the reactive value's current value to let it know it is being
-      # followed.
-      @klass.update_followers if @klass.respond_to?(:update_followers)
-    end
-
-    @callback.call(*args)
-  end
-
-  # Removes the listener from where ever it was created.
-  def remove
-    if @removed
-      # raise "event #{@event} already removed"
-      puts "event #{@event} already removed"
-      return
-    end
-
-    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)
-
-    # We need to clear these references to free the memory
-    @scope_provider = nil
-    @callback = nil
-    # @klass2 = @klass
-    @klass = nil
-    # @event = nil
-
-  end
-
-  def inspect
-    "<Listener:#{object_id} event=#{@event} scope=#{scope.inspect}#{' internal' if internal?}>"
-  end
-end
-
-module Events
-  # Add a listener for an event
-  def on(event, scope_provider=nil, &block)
-
-    event = event.to_sym
-
-    @has_listeners = true
-
-    new_listener = Listener.new(self, event, scope_provider, block)
-
-    @listeners ||= {}
-    @listeners[event] ||= []
-    @listeners[event] << new_listener
-
-    first_for_event = @listeners[event].size == 1
-    first = first_for_event && @listeners.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_for_event
-
-    # 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, scope_provider, first, first_for_event)
-    end
-
-    return new_listener
-  end
-
-  def event_chain
-    @event_chain ||= EventChain.new(self)
-  end
-
-  def listeners
-    @listeners || {}
-  end
-
-  def has_listeners?
-    @has_listeners
-  end
-
-  # Typically you would call .remove on the listener returned from the .on
-  # method.  However, here you can also pass in the original proc to remove
-  # a listener
-  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
-      # 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)
-    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
-
-    if last
-      @has_listeners = nil
-    end
-  end
-
-  def trigger!(event, filter=nil, *args)
-    # puts "TRIGGER: #{event} on #{self.inspect}" if event == :added
-    are_reactive = reactive?
-
-    event = event.to_sym
-
-    if @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
-        # 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
-        if (!filter || (!are_reactive && listener.scope_provider.reactive?) || filter.call(listener.scope))
-          listener.call(filter, *args)
-        end
-      end
-    end
-
-    nil
-  end
-
-  # 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
-      end
-    end
-  end
-
-end