volt 0.8.14 → 0.8.15

data/lib/volt/reactive/reactive_array.rb

@@ -1,232 +1,234 @@
 require 'volt/reactive/eventable'
 
-class ReactiveArray# < Array
-  include Eventable
-
-  def initialize(array=[])
-    @array = array
-    @array_deps = []
-    @size_dep = Dependency.new
-    @old_size = 0
-  end
+module Volt
+  class ReactiveArray
+    include Eventable
+
+    def initialize(array=[])
+      @array      = array
+      @array_deps = []
+      @size_dep   = Dependency.new
+      @old_size   = 0
+    end
 
-  # Forward any missing methods to the array
-  def method_missing(method_name, *args, &block)
-    @array.send(method_name, *args, &block)
-  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
+    def ==(*args)
+      @array.==(*args)
+    end
 
-  # At the moment, each just passes through.
-  def each(&block)
-    @array.each(&block)
-  end
+    # At the moment, each just passes through.
+    def each(&block)
+      @array.each(&block)
+    end
 
-  def count(&block)
-    if block
-      count = 0
-      size.times do |index|
-        if block.call(self[index]).true?
-          count += 1
+    def count(&block)
+      if block
+        count = 0
+        size.times do |index|
+          if block.call(self[index]).true?
+            count += 1
+          end
         end
-      end
-
-      return count
-    else
-      return size
-    end
-  end
 
-  def select
-    result = []
-    size.times do |index|
-      val = self[index]
-      if yield(val).true?
-        result << val
+        return count
+      else
+        return size
       end
     end
 
-    return result
-  end
-
-  def any?
-    if block_given?
+    def select
+      result = []
       size.times do |index|
         val = self[index]
-
         if yield(val).true?
-          return true
+          result << val
         end
       end
 
-      return false
-    else
-      return @array.any?
+      return result
     end
-  end
 
-  def all?
-    if block_given?
-      size.times do |index|
-        val = self[index]
+    def any?
+      if block_given?
+        size.times do |index|
+          val = self[index]
 
-        if !yield(val).true?
-          return false
+          if yield(val).true?
+            return true
+          end
         end
-      end
 
-      return true
-    else
-      return @array.all?
+        return false
+      else
+        return @array.any?
+      end
     end
-  end
-
-  # TODO: Handle a range
-  def [](index)
-    # Handle a negative index
-    index = size + index if index < 0
-
-    # Get or create the dependency
-    dep = (@array_deps[index] ||= Dependency.new)
 
-    # Track the dependency
-    dep.depend
+    def all?
+      if block_given?
+        size.times do |index|
+          val = self[index]
 
-    # Return the index
-    return @array[index]
-  end
+          if !yield(val).true?
+            return false
+          end
+        end
 
-  def []=(index, value)
+        return true
+      else
+        return @array.all?
+      end
+    end
 
-    # Assign the new value
-    @array[index] = value
+    # TODO: Handle a range
+    def [](index)
+      # Handle a negative index
+      index = size + index if index < 0
 
-    trigger_for_index!(index)
+      # Get or create the dependency
+      dep   = (@array_deps[index] ||= Dependency.new)
 
-    trigger_size_change!
-  end
+      # Track the dependency
+      dep.depend
 
-  def size
-    @size_dep.depend
+      # Return the index
+      return @array[index]
+    end
 
-    return @array.size
-  end
-  alias :length :size
+    def []=(index, value)
 
-  def delete_at(index)
-    # Handle a negative index
-    index = size + index if index < 0
+      # Assign the new value
+      @array[index] = value
 
-    model = @array.delete_at(index)
+      trigger_for_index!(index)
 
-    # Remove the dependency for that cell, and #remove it
-    index_deps = @array_deps.delete_at(index)
-    index_deps.remove if index_deps
+      trigger_size_change!
+    end
 
-    trigger_removed!(index)
+    def size
+      @size_dep.depend
 
-    # Trigger a changed event for each element in the zone where the
-    # delete would change
-    index.upto(self.size+1) do |position|
-      trigger_for_index!(position)
+      return @array.size
     end
 
-    trigger_size_change!
+    alias :length :size
 
-    @persistor.removed(model) if @persistor
+    def delete_at(index)
+      # Handle a negative index
+      index = size + index if index < 0
 
-    return model
-  end
+      model      = @array.delete_at(index)
 
+      # Remove the dependency for that cell, and #remove it
+      index_deps = @array_deps.delete_at(index)
+      index_deps.remove if index_deps
 
-  def delete(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
+      trigger_removed!(index)
 
-  def clear
-    old_size = @array.size
+      # Trigger a changed event for each element in the zone where the
+      # delete would change
+      index.upto(self.size+1) do |position|
+        trigger_for_index!(position)
+      end
+
+      trigger_size_change!
 
-    deps = @array_deps
-    @array_deps = []
+      @persistor.removed(model) if @persistor
 
-    # Trigger remove for each cell
-    old_size.times do |index|
-      trigger_removed!(old_size - index - 1)
+      return model
     end
 
-    # Trigger on each cell since we are clearing out the array
-    if deps
-      deps.each do |dep|
-        dep.changed! if dep
+
+    def delete(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
 
-    # clear the array
-    @array = []
-  end
+    def clear
+      old_size = @array.size
 
-  # alias :__old_append :<<
-  def <<(value)
-    result = (@array << value)
+      deps        = @array_deps
+      @array_deps = []
 
-    trigger_for_index!(self.size-1)
-    trigger_added!(self.size-1)
-    trigger_size_change!
+      # Trigger remove for each cell
+      old_size.times do |index|
+        trigger_removed!(old_size - index - 1)
+      end
 
-    return result
-  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 = []
+    end
 
-  def +(array)
-    raise "not implemented yet"
-    old_size = self.size
+    # alias :__old_append :<<
+    def <<(value)
+      result = (@array << value)
 
-    # TODO: += is funky here, might need to make a .plus! method
-    result = ReactiveArray.new(@array.dup + array)
+      trigger_for_index!(self.size-1)
+      trigger_added!(self.size-1)
+      trigger_size_change!
 
-    old_size.upto(result.size-1) do |index|
-      trigger_for_index!('changed', index)
-      trigger_added!(old_size + index)
+      return result
     end
 
-    trigger_size_change!
 
-    return result
-  end
+    def +(array)
+      raise "not implemented yet"
+      old_size = self.size
 
-  def insert(index, *objects)
-    result = @array.insert(index, *objects)
+      # TODO: += is funky here, might need to make a .plus! method
+      result   = ReactiveArray.new(@array.dup + array)
 
-    # All objects from index to the end have "changed"
-    index.upto(result.size) do |index|
-      trigger_for_index!(index)
-    end
+      old_size.upto(result.size-1) do |index|
+        trigger_for_index!('changed', index)
+        trigger_added!(old_size + index)
+      end
+
+      trigger_size_change!
 
-    objects.size.times do |count|
-      trigger_added!(index+count)
+      return result
     end
 
-    trigger_size_change!
+    def insert(index, *objects)
+      result = @array.insert(index, *objects)
 
-    return result
-  end
+      # All objects from index to the end have "changed"
+      index.upto(result.size) do |index|
+        trigger_for_index!(index)
+      end
 
+      objects.size.times do |count|
+        trigger_added!(index+count)
+      end
 
-  def inspect
-    "#<#{self.class.to_s}:#{object_id} #{@array.inspect}>"
-  end
+      trigger_size_change!
+
+      return result
+    end
 
 
-  private
+    def inspect
+      "#<#{self.class.to_s}:#{object_id} #{@array.inspect}>"
+    end
+
+
+    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
@@ -251,7 +253,5 @@ class ReactiveArray# < Array
     def trigger_removed!(index)
       trigger!('removed', index)
     end
-
-
-
+  end
 end

data/lib/volt/reactive/reactive_hash.rb

@@ -1,49 +1,51 @@
 require 'volt/reactive/hash_dependency'
 
-class ReactiveHash
-  def initialize(values={})
-    @hash = values
-    @deps = HashDependency.new
-    @all_deps = Dependency.new
-  end
+module Volt
+  class ReactiveHash
+    def initialize(values={})
+      @hash     = values
+      @deps     = HashDependency.new
+      @all_deps = Dependency.new
+    end
 
-  def ==(val)
-    @all_deps.depend
-    @hash == val
-  end
+    def ==(val)
+      @all_deps.depend
+      @hash == val
+    end
 
-  # TODO: We should finish off this class for reactivity
-  def method_missing(method_name, *args, &block)
-    @all_deps.depend
+    # TODO: We should finish off this class for reactivity
+    def method_missing(method_name, *args, &block)
+      @all_deps.depend
 
-    return @hash.send(method_name, *args, &block)
-  end
+      return @hash.send(method_name, *args, &block)
+    end
 
-  def [](key)
-    @deps.depend(key)
+    def [](key)
+      @deps.depend(key)
 
-    return @hash[key]
-  end
+      return @hash[key]
+    end
 
-  def []=(key, value)
-    @deps.changed!(key)
-    @all_deps.changed!
+    def []=(key, value)
+      @deps.changed!(key)
+      @all_deps.changed!
 
-    @hash[key] = value
-  end
+      @hash[key] = value
+    end
 
-  def delete(key)
-    @deps.delete(key)
-    @hash.delete(key)
-  end
+    def delete(key)
+      @deps.delete(key)
+      @hash.delete(key)
+    end
 
-  def clear
-    @hash.each_pair do |key,_|
-      delete(key)
+    def clear
+      @hash.each_pair do |key, _|
+        delete(key)
+      end
     end
-  end
 
-  def inspect
-    "#<ReactiveHash #{@hash.inspect}>"
+    def inspect
+      "#<ReactiveHash #{@hash.inspect}>"
+    end
   end
-end
+end