volt 0.6.5 → 0.7.0

data/lib/volt/models/array_model.rb

@@ -4,7 +4,7 @@ require 'volt/models/model_helpers'
 class ArrayModel < ReactiveArray
   include ModelWrapper
   include ModelHelpers
-  
+
   attr_reader :parent, :path, :persistor, :options
 
   def initialize(array=[], options={})
@@ -12,26 +12,26 @@ class ArrayModel < ReactiveArray
     @parent = options[:parent]
     @path = options[:path] || []
     @persistor = setup_persistor(options[:persistor])
-    
+
     array = wrap_values(array)
-    
+
     super(array)
-    
+
     @persistor.loaded if @persistor
   end
-  
-  # For stored items, tell the collection to load the data when it 
+
+  # For stored items, tell the collection to load the data when it
   # is requested.
   def [](index)
     load_data
     super
   end
-  
+
   def size
     load_data
     super
   end
-  
+
   def state
     if @persistor
       @persistor.state
@@ -39,11 +39,11 @@ class ArrayModel < ReactiveArray
       :loaded
     end
   end
-  
+
   def loaded?
     state == :loaded
   end
-  
+
   tag_method(:find) do
     destructive!
     pass_reactive!
@@ -55,11 +55,11 @@ class ArrayModel < ReactiveArray
       raise "this model's persistance layer does not support find, try using store"
     end
   end
-  
+
   def attributes
     self
   end
-  
+
   # Make sure it gets wrapped
   def <<(model)
     if model.cur.is_a?(Model)
@@ -68,12 +68,12 @@ class ArrayModel < ReactiveArray
     else
       model = wrap_values([model]).first
     end
-    
+
     super(model)
-    
+
     @persistor.added(model, @array.size-1) if @persistor
   end
-  
+
   # Make sure it gets wrapped
   def inject(*args)
     args = wrap_values(args)
@@ -89,21 +89,21 @@ class ArrayModel < ReactiveArray
   def new_model(attributes, options)
     class_at_path(options[:path]).new(attributes, options)
   end
-  
+
   def new_array_model(*args)
     ArrayModel.new(*args)
   end
-  
+
   # Convert the model to an array all of the way down
   def to_a
     array = []
-    attributes.each do |value|      
+    attributes.each do |value|
       array << deep_unwrap(value)
     end
-    
+
     return array
   end
-  
+
   def inspect
     if @persistor && @persistor.is_a?(Persistors::ArrayStore) && state == :not_loaded
       # Show a special message letting users know it is not loaded yet.
@@ -113,8 +113,8 @@ class ArrayModel < ReactiveArray
     # Otherwise inspect normally
     super
   end
-  
-  
+
+
   private
     # Takes the persistor if there is one and
     def setup_persistor(persistor)
@@ -122,13 +122,13 @@ class ArrayModel < ReactiveArray
         @persistor = persistor.new(self)
       end
     end
-    
+
     # Loads data in an array store persistor when data is requested.
     def load_data
       if @persistor && @persistor.is_a?(Persistors::ArrayStore)
         @persistor.load_data
       end
     end
-  
-    
-end
+
+
+end

data/lib/volt/models/model.rb

@@ -8,7 +8,7 @@ class NilMethodCall < NoMethodError
   def true?
     false
   end
-  
+
   def false?
     true
   end
@@ -20,18 +20,18 @@ class Model
   include ObjectTracking
   include ModelHelpers
   include ModelHashBehaviour
-  
+
   attr_accessor :attributes
   attr_reader :parent, :path, :persistor, :options
-  
+
   def initialize(attributes={}, options={})
     self.options = options
 
     self.attributes = wrap_values(attributes)
-    
+
     @persistor.loaded if @persistor
   end
-  
+
   # Update the options
   def options=(options)
     @options = options
@@ -40,8 +40,8 @@ class Model
     @class_paths = options[:class_paths]
     @persistor = setup_persistor(options[:persistor])
   end
-  
-  
+
+
   # Pass the comparison through
   def ==(val)
     if val.is_a?(Model)
@@ -52,13 +52,13 @@ class Model
       return attributes == val
     end
   end
-  
+
   # Pass through needed
   def !
     !attributes
   end
 
-  
+
   tag_all_methods do
     pass_reactive! do |method_name|
       method_name[0] == '_' && method_name[-1] == '='
@@ -78,23 +78,23 @@ class Model
       attributes.send(method_name, *args, &block)
     end
   end
-  
+
   # Do the assignment to a model and trigger a changed event
   def assign_attribute(method_name, *args, &block)
     self.expand!
     # Assign, without the =
     attribute_name = method_name[0..-2].to_sym
-    
+
     value = args[0]
     __assign_element(attribute_name, value)
-    
+
     attributes[attribute_name] = wrap_value(value, [attribute_name])
     trigger_by_attribute!('changed', attribute_name)
-    
+
     # Let the persistor know something changed
     @persistor.changed(attribute_name) if @persistor
   end
-  
+
   # When reading an attribute, we need to handle reading on:
   # 1) a nil model, which returns a wrapped error
   # 2) reading directly from attributes
@@ -102,9 +102,9 @@ class Model
   def read_attribute(method_name)
     # Reading an attribute, we may get back a nil model.
     method_name = method_name.to_sym
-    
+
     if method_name[0] != '_' && attributes == nil
-      # The method we are calling is on a nil model, return a wrapped 
+      # The method we are calling is on a nil model, return a wrapped
       # exception.
       return return_undefined_method(method_name)
     elsif attributes && attributes.has_key?(method_name)
@@ -123,7 +123,7 @@ class Model
       return new_model(nil, @options.merge(parent: self, path: path + [method_name]))
     end
   end
-  
+
   def return_undefined_method(method_name)
     # Methods called on nil capture an error so the user can know where
     # their nil calls are.  This error can be re-raised at a later point.
@@ -137,28 +137,28 @@ class Model
       result.backtrace.reject! {|line| line['lib/models/model.rb'] || line['lib/models/live_value.rb'] }
     end
   end
-  
+
   def new_model(attributes, options)
     class_at_path(options[:path]).new(attributes, options)
   end
-  
+
   def new_array_model(*args)
     ArrayModel.new(*args)
   end
-  
+
   def trigger_by_attribute!(event_name, attribute, *passed_args)
     trigger_by_scope!(event_name, *passed_args) do |scope|
       method_name, *args, block = scope
-      
+
       # TODO: Opal bug
       args ||= []
-      
+
       # Any methods without _ are not directly related to one attribute, so
       # they should all trigger
       !method_name || method_name[0] != '_' || (method_name == attribute.to_sym && args.size == 0)
     end
   end
-  
+
   # If this model is nil, it makes it into a hash model, then
   # sets it up to track from the parent.
   def expand!
@@ -166,12 +166,12 @@ class Model
       self.attributes = {}
       if @parent
         @parent.expand!
-      
+
         @parent.attributes[@path.last] = self
       end
     end
   end
-  
+
   tag_method(:<<) do
     pass_reactive!
   end
@@ -186,7 +186,7 @@ class Model
     # Grab the last section of the path, so we can do the assign on the parent
     path = @path.last
     result = @parent.send(path)
-    
+
     if result.nil?
       # If this isn't a model yet, instantiate it
       @parent.send(:"#{path}=", new_array_model([], @options))
@@ -195,47 +195,47 @@ class Model
 
     # Add the new item
     result << value
-    
+
     return nil
   end
-  
+
   def inspect
     "<#{self.class.to_s} #{attributes.inspect}>"
   end
-  
+
   def deep_cur
     attributes
   end
-  
+
   private
     # Clear the previous value and assign a new one
     def __assign_element(key, value)
       __clear_element(key)
       __track_element(key, value)
     end
-    
+
     # TODO: Somewhat duplicated from ReactiveArray
     def __clear_element(key)
       # Cleanup any tracking on an index
       # TODO: is this send a security risk?
       # puts "TRY TO CLEAR: #{key} - #{@reactive_element_listeners && @reactive_element_listeners.keys.inspect}"
-      if @reactive_element_listeners && @reactive_element_listeners[key]        
+      if @reactive_element_listeners && @reactive_element_listeners[key]
         @reactive_element_listeners[key].remove
         @reactive_element_listeners.delete(key)
       end
     end
-  
+
     def __track_element(key, value)
       __setup_tracking(key, value) do |event, key, args|
         trigger_by_attribute!(event, key, *args)
       end
     end
-    
+
     # Takes the persistor if there is one and
     def setup_persistor(persistor)
       if persistor
         @persistor = persistor.new(self)
       end
     end
-    
+
 end

data/lib/volt/models/model_hash_behaviour.rb

@@ -8,54 +8,54 @@ module ModelHashBehaviour
     base.tag_method(:delete) do
       destructive!
     end
-    
+
     base.tag_method(:clear) do
       destructive!
     end
   end
-  
-  
+
+
   def nil?
     attributes.nil?
   end
-  
+
   def false?
     attributes.false?
   end
-  
+
   def true?
     attributes.true?
   end
-  
+
   def delete(*args)
     __clear_element(args[0])
     attributes.delete(*args)
     trigger_by_attribute!('changed', args[0])
-    
+
     @persistor.removed(args[0]) if @persistor
   end
-  
+
 
   def clear
     attributes.each_pair do |key,value|
-      __clear_element(key)      
+      __clear_element(key)
     end
 
     attributes.clear
     trigger!('changed')
-    
+
     @persistor.removed(nil) if @persistor
   end
-  
-  
+
+
   # Convert the model to a hash all of the way down.
   def to_h
     hash = {}
     attributes.each_pair do |key, value|
       hash[key] = deep_unwrap(value)
     end
-    
+
     return hash
   end
-  
-end
+
+end

data/lib/volt/models/model_helpers.rb

@@ -7,30 +7,30 @@ module ModelHelpers
     elsif value.is_a?(ArrayModel)
       value = value.to_a
     end
-    
+
     return value
   end
-  
+
   # Pass to the persisotr
   def event_added(event, scope_provider, first)
     @persistor.event_added(event, scope_provider, first) if @persistor
   end
-  
+
   # Pass to the persistor
   def event_removed(event, no_more_events)
     @persistor.event_removed(event, no_more_events) if @persistor
   end
-  
+
   # Gets the class for a model at the specified path.
   def class_at_path(path)
     if path && path.last == :[]
       begin
         # TODO: SECURITY on the back-end we need to check that the model class we're loading
         # is coming from the models folder.
-        
+
         # remove the _ and then singularize
         klass_name = path[-2][1..-1].singularize.camelize
-        
+
         klass_name = klass_name.camelize
         klass = Object.send(:const_get, klass_name.to_sym)
       rescue NameError => e
@@ -40,7 +40,7 @@ module ModelHelpers
     else
       klass = Model
     end
-    
+
     return klass
   end
-end
+end

data/lib/volt/models/model_wrapper.rb

@@ -7,10 +7,10 @@ module ModelWrapper
     elsif value.cur.is_a?(Hash)
       value = new_model(value, @options.merge(parent: self, path: path + lookup))
     end
-    
+
     return value
   end
-  
+
   def wrap_values(values, lookup=[])
     if values.cur.is_a?(Array)
       # Coming from an array
@@ -18,13 +18,13 @@ module ModelWrapper
     elsif values.cur.is_a?(Hash)
       pairs = values.map do |k,v|
         path = lookup + [k]
-            
+
         [k, wrap_value(v,path)]
       end
-      
+
       values = Hash[pairs]
     end
-    
+
     return values
   end
-end
+end

data/lib/volt/models/persistors/array_store.rb

@@ -4,39 +4,39 @@ require 'volt/models/persistors/query/query_listener_pool'
 module Persistors
   class ArrayStore < Store
     @@query_pool = QueryListenerPool.new
-    
+
     attr_reader :model
     attr_accessor :state
-    
+
     def self.query_pool
       @@query_pool
     end
-    
+
     def initialize(model, tasks=nil)
       super
-      
+
       @query = ReactiveValue.from_hash(@model.options[:query] || {})
-      
+
     end
-    
+
     # Called when a collection loads
     def loaded
       change_state_to :not_loaded
     end
-    
+
     def event_added(event, scope_provider, first)
       puts "ADD EV: #{event} - #{first}"
       # First event, we load the data.
       load_data if first
     end
-    
+
     def event_removed(event, no_more_events)
       # Remove listener where there are no more events on this model
       if no_more_events && @query_listener && @model.listeners.size == 0
         stop_listening
       end
     end
-    
+
     # Called when an event is removed and we no longer want to keep in
     # sync with the database.
     def stop_listening
@@ -49,7 +49,7 @@ module Persistors
     # Called from the QueryListener when the data is loaded
     def change_state_to(new_state)
       @state = new_state
-      
+
       # Trigger changed on the 'state' method
       @model.trigger_for_methods!('changed', :state, :loaded?)
     end
@@ -60,13 +60,13 @@ module Persistors
       if @state == :not_loaded || @state == :dirty
         puts "Load Data"
         change_state_to :loading
-        
+
         @query_changed_listener.remove if @query_changed_listener
         if @query.reactive?
           # Query might change, change the query when it does
           @query_changed_listener = @query.on('changed') do
             stop_listening
-            
+
             load_data
           end
         end
@@ -74,21 +74,21 @@ module Persistors
         run_query(@model, @query.deep_cur)
       end
     end
-    
+
     # Clear out the models data, since we're not listening anymore.
     def unload_data
       change_state_to :not_loaded
       @model.clear
     end
-    
+
     def run_query(model, query={})
       collection = model.path.last
       # Scope to the parent
       if model.path.size > 1
         parent = model.parent
-      
+
         parent.persistor.ensure_setup if parent.persistor
-      
+
         if parent && (attrs = parent.attributes) && attrs[:_id].true?
           query[:"#{model.path[-3].singularize}_id"] = attrs[:_id]
         end
@@ -100,32 +100,32 @@ module Persistors
       end
       @query_listener.add_store(model.persistor)
     end
-    
+
     def find(query={})
       model = ArrayModel.new([], @model.options.merge(:query => query))
-      
+
       return ReactiveValue.new(model)
     end
-    
+
     # Called from backend
     def add(index, data)
       $loading_models = true
-      
+
       new_options = @model.options.merge(path: @model.path + [:[]], parent: @model)
-      
+
       # Find the existing model, or create one
       new_model = @@identity_map.find(data['_id']) { Model.new(data.symbolize_keys, new_options) }
-      
+
       @model.insert(index, new_model)
-      
-      $loading_models = false      
+
+      $loading_models = false
     end
-    
+
     def remove(ids)
       $loading_models = true
       ids.each do |id|
         puts "delete at: #{id} on #{@model.inspect}"
-        
+
         # TODO: optimize this delete so we don't need to loop
         @model.each_with_index do |model, index|
           puts "#{model._id.inspect} vs #{id.inspect} - #{index}"
@@ -136,34 +136,34 @@ module Persistors
           end
         end
       end
-      
+
       $loading_models = false
     end
-    
+
     def channel_name
       @model.path[-1]
     end
-    
-    
+
+
     # When a model is added to this collection, we call its "changed"
     # method.  This should trigger a save.
     def added(model, index)
       unless defined?($loading_models) && $loading_models
         model.persistor.changed
       end
-      
+
       if model.persistor
         # Tell the persistor it was added
         model.persistor.add_to_collection
       end
     end
-    
-    def removed(model)      
+
+    def removed(model)
       if model.persistor
         # Tell the persistor it was removed
         model.persistor.remove_from_collection
       end
-      
+
       if $loading_models
         return
       else
@@ -171,6 +171,6 @@ module Persistors
         @tasks.call('StoreTasks', 'delete', channel_name, model.attributes[:_id])
       end
     end
-    
+
   end
-end
+end