volt 0.8.14 → 0.8.15

data/lib/volt/reactive/computation.rb

@@ -1,121 +1,120 @@
-class Computation
-  @@current = nil
-  @@flush_queue = []
-
+module Volt
+  class Computation
+    @@current     = nil
+    @@flush_queue = []
 
-  def self.current=(val)
-    @@current = val
-  end
+    def self.current=(val)
+      @@current = val
+    end
 
-  def self.current
-    @@current
-  end
+    def self.current
+      @@current
+    end
 
-  def initialize(computation)
-    @computation = computation
-    @invalidations = []
-  end
+    def initialize(computation)
+      @computation   = computation
+      @invalidations = []
+    end
 
-  # Runs the computation
-  def compute!
-    @invalidated = false
+    # Runs the computation
+    def compute!
+      @invalidated = false
 
-    unless @stopped
+      unless @stopped
 
-      @computing = true
-      run_in do
-        @computation.call
+        @computing = true
+        run_in do
+          @computation.call
+        end
+        @computing = false
       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
+    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
-    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
+    # 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 !@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!
+          # If we are in the browser, we queue a flush for the next tick
+          if Volt.in_browser?
+            self.class.queue_flush!
+          end
         end
-      end
 
-      invalidations = @invalidations
-      @invalidations = []
+        invalidations  = @invalidations
+        @invalidations = []
 
-      invalidations.each do |invalidation|
-        invalidation.call
+        invalidations.each do |invalidation|
+          invalidation.call
+        end
       end
     end
-  end
 
-  # Stop re-run of the computations
-  def stop
-    unless @stopped
-      @stopped = true
-      invalidate!
+    # Stop re-run of the computations
+    def stop
+      unless @stopped
+        @stopped = true
+        invalidate!
+      end
     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
+    # Runs in this computation as the current computation, returns the computation
+    def run_in
+      previous            = Computation.current
+      Computation.current = self
+      yield
+      Computation.current = previous
+      self
+    end
 
-  def self.run_without_tracking
-    previous = Computation.current
-    Computation.current = nil
-    return_value = yield
-    Computation.current = previous
+    def self.run_without_tracking
+      previous            = Computation.current
+      Computation.current = nil
+      return_value        = yield
+      Computation.current = previous
+      return_value
+    end
 
-    return return_value
-  end
 
+    def self.flush!
+      raise "Can't flush while in a flush" if @flushing
 
-  def self.flush!
-    raise "Can't flush while in a flush" if @flushing
+      @flushing = true
+      # clear any timers
+      @timer    = nil
 
-    @flushing = true
-    # clear any timers
-    @timer = nil
+      computations  = @@flush_queue
+      @@flush_queue = []
 
-    computations = @@flush_queue
-    @@flush_queue = []
+      computations.each do |computation|
+        computation.compute!
+      end
 
-    computations.each do |computation|
-      computation.compute!
+      @flushing = false
     end
 
-    @flushing = false
-  end
-
-  def self.queue_flush!
-    if !@timer
-      # Flush once everything else has finished running
-      @timer = `setImmediate(function() { self['$flush!'](); });`
+    def self.queue_flush!
+      if !@timer
+        # Flush once everything else has finished running
+        @timer = `setImmediate(function() { self['$flush!'](); });`
+      end
     end
   end
 end
@@ -123,7 +122,7 @@ end
 
 class Proc
   def watch!
-    return Computation.new(self).run_in do
+    Volt::Computation.new(self).run_in do
       # run self
       self.call
     end

data/lib/volt/reactive/dependency.rb

@@ -27,45 +27,47 @@ class Set
   end
 end
 
-class Dependency
-  def initialize
-    @dependencies = Set.new
-  end
+module Volt
+  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
+    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)
+      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
+        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
-  end
 
-  def changed!
-    deps = @dependencies
+    def changed!
+      deps = @dependencies
 
-    # If no deps, dependency has been removed
-    return unless deps
+      # If no deps, dependency has been removed
+      return unless deps
 
-    @dependencies = Set.new
+      @dependencies = Set.new
 
-    deps.each do |dep|
-      dep.invalidate!
+      deps.each do |dep|
+        dep.invalidate!
+      end
     end
-  end
 
-  # Called when a dependency is no longer needed
-  def remove
-    changed!
-    @dependencies = nil
+    # Called when a dependency is no longer needed
+    def remove
+      changed!
+      @dependencies = nil
+    end
   end
 end

data/lib/volt/reactive/eventable.rb

@@ -1,82 +1,84 @@
-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
+module Volt
+  class Listener
+    def initialize(klass, event, callback)
+      @klass    = klass
+      @event    = event
+      @callback = callback
+    end
 
-    @klass.remove_listener(@event, self)
+    def call(*args)
+      @callback.call(*args) unless @removed
+    end
 
-    # Make things easier on the GC
-    @klass = nil
-    @callback = nil
-  end
+    def remove
+      @removed = true
 
-  def inspect
-     "<Listener:#{object_id} event=#{@event}>"
-   end
-end
+      @klass.remove_listener(@event, self)
 
-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)
+      # Make things easier on the GC
+      @klass    = nil
+      @callback = nil
     end
 
-    return listener
+    def inspect
+      "<Listener:#{object_id} event=#{@event}>"
+    end
   end
 
-  def trigger!(event, *args)
-    event = event.to_sym
+  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]
+      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)
+      # 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
-  end
 
-  def remove_listener(event, listener)
-    event = event.to_sym
+    def remove_listener(event, listener)
+      event = event.to_sym
 
-    raise "Unable to delete #{event} from #{self.inspect}" unless @listeners && @listeners[event]
+      raise "Unable to delete #{event} from #{self.inspect}" unless @listeners && @listeners[event]
 
-    @listeners[event].delete(listener)
+      @listeners[event].delete(listener)
 
-    last_for_event = @listeners[event].size == 0
+      last_for_event = @listeners[event].size == 0
 
-    if last_for_event
-      # No registered listeners now on this event
-      @listeners.delete(event)
-    end
+      if last_for_event
+        # No registered listeners now on this event
+        @listeners.delete(event)
+      end
 
-    last = last_for_event && @listeners.size == 0
+      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)
+      # 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
-end
+end

data/lib/volt/reactive/hash_dependency.rb

@@ -1,35 +1,37 @@
-class HashDependency
-  def initialize
-    @hash_depedencies = {}
-  end
+module Volt
+  class HashDependency
+    def initialize
+      @hash_depedencies = {}
+    end
 
-  def depend(key)
-    ensure_key(key).depend
-  end
+    def depend(key)
+      ensure_key(key).depend
+    end
 
-  def changed!(key)
-    ensure_key(key).changed!
-  end
+    def changed!(key)
+      ensure_key(key).changed!
+    end
 
-  def delete(key)
-    dep = @hash_depedencies[key]
+    def delete(key)
+      dep = @hash_depedencies[key]
 
-    if dep
-      dep.changed!
-      dep.remove
-    end
+      if dep
+        dep.changed!
+        dep.remove
+      end
 
-    @hash_depedencies.delete(key)
-  end
+      @hash_depedencies.delete(key)
+    end
 
-  def changed_all!
-    @hash_depedencies.each_pair do |key,value|
-      value.changed!
+    def changed_all!
+      @hash_depedencies.each_pair do |key, value|
+        value.changed!
+      end
     end
-  end
 
-  private
+    private
     def ensure_key(key)
       @hash_depedencies[key] ||= Dependency.new
     end
+  end
 end

data/lib/volt/reactive/reactive_accessors.rb

@@ -1,45 +1,47 @@
-module ReactiveAccessors
-
-  module ClassMethods
-    # 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
+module Volt
+  module ReactiveAccessors
+
+    module ClassMethods
+      # 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)
+      def reactive_reader(*names)
+        names.each do |name|
+          var_name = :"@#{name}"
+          define_method(name.to_sym) do
+            value = instance_variable_get(var_name)
 
-          self.class.__reactive_dependency_get(name).depend
+            self.class.__reactive_dependency_get(name).depend
 
-          value
+            value
+          end
         end
       end
-    end
 
-    def reactive_writer(*names)
-      names.each do |name|
-        var_name = :"@#{name}"
-        define_method(:"#{name}=") do |new_value|
-          instance_variable_set(var_name, new_value)
+      def reactive_writer(*names)
+        names.each do |name|
+          var_name = :"@#{name}"
+          define_method(:"#{name}=") do |new_value|
+            instance_variable_set(var_name, new_value)
 
-          self.class.__reactive_dependency_get(name).changed!
+            self.class.__reactive_dependency_get(name).changed!
+          end
         end
       end
-    end
 
-    def reactive_accessor(*names)
-      reactive_reader(*names)
-      reactive_writer(*names)
+      def reactive_accessor(*names)
+        reactive_reader(*names)
+        reactive_writer(*names)
+      end
     end
-  end
 
-  def self.included(base)
-    base.send :extend, ClassMethods
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
   end
-end
+end