volt 0.7.23 → 0.8.0

data/lib/volt/extra_core/string.rb

@@ -23,6 +23,10 @@ class String
     Inflector.singularize(self)
   end
 
+  def titleize
+    self.gsub('_', ' ').split(' ').map {|w| w.capitalize }.join(' ')
+  end
+
   def plural?
     # TODO: Temp implementation
     self.pluralize == self

data/lib/volt/models.rb

@@ -1,5 +1,4 @@
 require 'volt/extra_core/extra_core'
-require 'volt/reactive/reactive_value'
 require 'volt/models/model'
 require 'volt/models/cursor'
 require 'volt/models/persistors/store_factory'

data/lib/volt/models/array_model.rb

@@ -1,3 +1,4 @@
+require 'volt/reactive/reactive_array'
 require 'volt/models/model_wrapper'
 require 'volt/models/model_helpers'
 require 'volt/models/model_state'
@@ -36,21 +37,14 @@ class ArrayModel < ReactiveArray
     @persistor.loaded if @persistor
   end
 
-  tag_method(:find) do
-    destructive!
-    pass_reactive!
-  end
-  def find(*args)
+  def find(*args, &block)
     if @persistor
-      return @persistor.find(*args)
+      return @persistor.find(*args, &block)
     else
       raise "this model's persistance layer does not support find, try using store"
     end
   end
 
-  tag_method(:then) do
-    destructive!
-  end
   def then(*args, &block)
     if @persistor
       return @persistor.then(*args, &block)
@@ -65,9 +59,10 @@ class ArrayModel < ReactiveArray
 
   # Make sure it gets wrapped
   def <<(model)
-    if model.cur.is_a?(Model)
+    # TODORW: handle changes
+    if model.is_a?(Model)
       # Set the new path
-      model.cur.options = @options.merge(path: @options[:path] + [:[]])
+      model.options = @options.merge(path: @options[:path] + [:[]])
     else
       model = wrap_values([model]).first
     end
@@ -117,12 +112,9 @@ class ArrayModel < ReactiveArray
     end
 
     # Otherwise inspect normally
-    super
+    return super
   end
 
-  tag_method(:buffer) do
-    destructive!
-  end
   def buffer
     model_path = options[:path] + [:[]]
     model_klass = class_at_path(model_path)
@@ -130,7 +122,7 @@ class ArrayModel < ReactiveArray
     new_options = options.merge(path: model_path, save_to: self).reject {|k,_| k.to_sym == :persistor }
     model = model_klass.new({}, new_options)
 
-    return ReactiveValue.new(model)
+    return model
   end
 
   private

data/lib/volt/models/cursor.rb

@@ -1,6 +1,6 @@
 require 'volt/models/array_model'
 
 class Cursor < ArrayModel
-  
+
 
 end

data/lib/volt/models/model.rb

@@ -1,42 +1,34 @@
 require 'volt/models/model_wrapper'
 require 'volt/models/array_model'
 require 'volt/models/model_helpers'
-require 'volt/reactive/object_tracking'
 require 'volt/models/model_hash_behaviour'
 require 'volt/models/validations'
 require 'volt/models/model_state'
-
+require 'volt/reactive/reactive_hash'
 
 class NilMethodCall < NoMethodError
-  def true?
-    false
-  end
-
-  def false?
-    true
-  end
 end
 
+
 class Model
-  include ReactiveTags
   include ModelWrapper
-  include ObjectTracking
   include ModelHelpers
   include ModelHashBehaviour
   include Validations
   include ModelState
 
-  attr_accessor :attributes
+  attr_reader :attributes
   attr_reader :parent, :path, :persistor, :options
 
   def initialize(attributes={}, options={}, initial_state=nil)
+    @deps = HashDependency.new
     self.options = options
 
     self.send(:attributes=, attributes, true)
 
     @cache = {}
 
-    # Models stat in a loaded state since they are normally setup from an
+    # Models start in a loaded state since they are normally setup from an
     # ArrayModel, which will have the data when they get added.
     @state = :loaded
 
@@ -56,8 +48,11 @@ class Model
   def attributes=(attrs, initial_setup=false)
     @attributes = wrap_values(attrs)
 
+    # Trigger and change all
+    @deps.changed_all!
+    @deps = HashDependency.new
+
     unless initial_setup
-      trigger!('changed')
 
       # Let the persistor know something changed
       if @persistor
@@ -86,11 +81,6 @@ class Model
   end
 
 
-  tag_all_methods do
-    pass_reactive! do |method_name|
-      method_name[0] == '_' && method_name[-1] == '='
-    end
-  end
   def method_missing(method_name, *args, &block)
     if method_name[0] == '_'
       if method_name[-1] == '='
@@ -116,10 +106,9 @@ class Model
     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)
+    @deps.changed!(attribute_name)
 
     # Let the persistor know something changed
     @persistor.changed(attribute_name) if @persistor
@@ -144,6 +133,9 @@ class Model
       # Also check @cache
       value ||= (@cache && @cache[method_name])
 
+      # Track dependency
+      @deps.depend(method_name)
+
       if value
         # key was in attributes or cache
         return value
@@ -162,9 +154,14 @@ class Model
   # Get a new model, make it easy to override
   def read_new_model(method_name)
     if @persistor && @persistor.respond_to?(:read_new_model)
-      @persistor.read_new_model(method_name)
+      return @persistor.read_new_model(method_name)
     else
-      return new_model(nil, @options.merge(parent: self, path: path + [method_name]))
+      opts = @options.merge(parent: self, path: path + [method_name])
+      if method_name.plural?
+        return new_array_model([], opts)
+      else
+        return new_model(nil, opts)
+      end
     end
   end
 
@@ -225,9 +222,6 @@ class Model
     end
   end
 
-  tag_method(:<<) do
-    pass_reactive!
-  end
   # Initialize an empty array and append to it
   def <<(value)
     if @parent
@@ -249,14 +243,20 @@ class Model
     # Add the new item
     result << value
 
-    trigger!('added', nil, 0)
-    trigger!('changed')
+    # TODORW:
+    # trigger!('added', nil, 0)
+    # trigger!('changed')
 
     return nil
   end
 
   def inspect
-    "<#{self.class.to_s}:#{object_id} #{attributes.inspect}>"
+    str = nil
+    Computation.run_without_tracking do
+      str = "<#{self.class.to_s}:#{object_id} #{attributes.inspect}>"
+    end
+
+    return str
   end
 
   def deep_cur
@@ -294,7 +294,6 @@ class Model
       self.class.validations.keys.each do |key|
         mark_field!(key.to_sym)
       end
-      trigger_for_methods!('changed', :errors, :marked_errors)
 
       return Promise.new.reject(errors)
     end
@@ -302,12 +301,15 @@ class Model
 
 
   # Returns a buffered version of the model
-  tag_method(:buffer) do
-    destructive!
-  end
   def buffer
     model_path = options[:path]
-    model_klass = class_at_path(model_path)
+
+    # When we grab a buffer off of a plual class (subcollection), we get it as a model.
+    if model_path.last.plural? && model_path[-1] != :[]
+      model_klass = class_at_path(model_path + [:[]])
+    else
+      model_klass = class_at_path(model_path)
+    end
 
     new_options = options.merge(path: model_path, save_to: self).reject {|k,_| k.to_sym == :persistor }
     model = model_klass.new({}, new_options, :loading)
@@ -320,36 +322,14 @@ class Model
       end
     end
 
-    return ReactiveValue.new(model)
+    return model
   end
 
 
   private
-  def setup_buffer(model)
-    model.attributes = self.attributes
-    model.change_state_to(:loaded)
-  end
-
-    # 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?
-      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
+    def setup_buffer(model)
+      model.attributes = self.attributes
+      model.change_state_to(:loaded)
     end
 
     # Takes the persistor if there is one and

data/lib/volt/models/model_hash_behaviour.rb

@@ -2,18 +2,17 @@
 # Moving this into a module cleans up the main Model class for things that
 # make it behave like a model.
 module ModelHashBehaviour
-  def self.included(base)
-    # In modules, since we need to tag on the main class, we setup the
-    # tags with included.
-    base.tag_method(:delete) do
-      destructive!
-    end
 
-    base.tag_method(:clear) do
-      destructive!
-    end
-  end
+  def delete(name)
+    name = name.to_sym
 
+    value = attributes.delete(name)
+    @deps.delete(name)
+
+    @persistor.removed(name) if @persistor
+
+    return value
+  end
 
   def nil?
     attributes.nil?
@@ -27,25 +26,12 @@ module ModelHashBehaviour
     attributes.true?
   end
 
-  def delete(name)
-    name = name.to_sym
-    __clear_element(name)
-    value = attributes.delete(name)
-    trigger_by_attribute!('changed', name)
-
-    @persistor.removed(name) if @persistor
-
-    return value
-  end
-
-
   def clear
     attributes.each_pair do |key,value|
-      __clear_element(key)
+      @deps.changed!(key)
     end
 
     attributes.clear
-    trigger!('changed')
 
     @persistor.removed(nil) if @persistor
   end

data/lib/volt/models/model_helpers.rb

@@ -12,8 +12,8 @@ module ModelHelpers
   end
 
   # Pass to the persisotr
-  def event_added(event, scope_provider, first, first_for_event)
-    @persistor.event_added(event, scope_provider, first, first_for_event) if @persistor
+  def event_added(event, first, first_for_event)
+    @persistor.event_added(event, first, first_for_event) if @persistor
   end
 
   # Pass to the persistor

data/lib/volt/models/model_state.rb

@@ -15,7 +15,7 @@ module ModelState
   end
 
   def loaded?
-    state == :loaded
+    self.state == :loaded
   end
 
 

data/lib/volt/models/model_wrapper.rb

@@ -2,9 +2,9 @@ module ModelWrapper
   # For cretain values, we wrap them to make the behave as a
   # model.
   def wrap_value(value, lookup)
-    if value.cur.is_a?(Array)
+    if value.is_a?(Array)
       value = new_array_model(value, @options.merge(parent: self, path: path + lookup))
-    elsif value.cur.is_a?(Hash)
+    elsif value.is_a?(Hash)
       value = new_model(value, @options.merge(parent: self, path: path + lookup))
     end
 
@@ -12,10 +12,10 @@ module ModelWrapper
   end
 
   def wrap_values(values, lookup=[])
-    if values.cur.is_a?(Array)
+    if values.is_a?(Array)
       # Coming from an array
       values = values.map {|v| wrap_value(v,lookup + [:[]]) }
-    elsif values.cur.is_a?(Hash)
+    elsif values.is_a?(Hash)
       pairs = values.map do |k,v|
         path = lookup + [k]
 

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

@@ -17,28 +17,32 @@ module Persistors
     def initialize(model, tasks=nil)
       super
 
-      query = @model.options[:query]
-
-      @query = ReactiveValue.from_hash(query || {})
+      @query = @model.options[:query]
     end
 
-    def event_added(event, scope_provider, first, first_for_event)
+    def event_added(event, first, first_for_event)
       # First event, we load the data.
-      load_data if first
+      if first
+        @has_events = true
+        load_data
+      end
     end
 
     def event_removed(event, last, last_for_event)
       # Remove listener where there are no more events on this model
-      stop_listening if last
+      if last
+        @has_events = false
+        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
-      if @query_changed_listener
-        @query_changed_listener.remove
-        @query_changed_listener = nil
-      end
+    def stop_listening(stop_watching_query=true)
+      return if @has_events
+      return if @fetch_promises && @fetch_promises.size > 0
+
+      @query_computation.stop if @query_computation && stop_watching_query
 
       if @query_listener
         @query_listener.remove_store(self)
@@ -52,22 +56,21 @@ module Persistors
     def load_data
       # Don't load data from any queried
       if @state == :not_loaded || @state == :dirty
-        # puts "Load Data at #{@model.path.inspect} - query: #{@query.inspect}"# on #{@model.inspect}"
+        # puts "Load Data at #{@model.path.inspect} - query: #{@query.inspect} on #{self.inspect}"
         change_state_to :loading
 
-        @query_changed_listener.remove if @query_changed_listener
-        if @query.reactive?
-          # puts "SETUP REACTIVE QUERY LISTENER: #{@query.inspect}"
-          # Query might change, change the query when it does
-          @query_changed_listener = @query.on('changed') do
-            stop_listening
+        if @query.is_a?(Proc)
+          @query_computation = -> do
+            puts "Run Query Again"
+            stop_listening(false)
 
-            # Don't load again if all of the listeners are gone
-            load_data if @model.has_listeners?
-          end
-        end
+            change_state_to :loading
 
-        run_query(@model, @query.deep_cur)
+            run_query(@model, @query.call)
+          end.watch!
+        else
+          run_query(@model, @query)
+        end
       end
     end
 
@@ -78,6 +81,9 @@ module Persistors
     end
 
     def run_query(model, query={})
+      @model.clear
+
+      # puts "Run Query: #{query.inspect}"
       collection = model.path.last
       # Scope to the parent
       if model.path.size > 1
@@ -98,10 +104,20 @@ module Persistors
       @query_listener.add_store(self)
     end
 
-    def find(query={})
-      model = Cursor.new([], @model.options.merge(:query => query))
+    # Find can take either a query object, or a block that returns a query object.  Use
+    # the block style if you need reactive updating queries
+    def find(query=nil, &block)
+      # Set a default query if there is no block
+      if block
+        if query
+          raise "Query should not be passed in to a find if a block is specified"
+        end
+        query = block
+      else
+        query ||= {}
+      end
 
-      return ReactiveValue.new(model)
+      return Cursor.new([], @model.options.merge(:query => query))
     end
 
     # Returns a promise that is resolved/rejected when the query is complete.  Any
@@ -130,7 +146,7 @@ module Persistors
       new_options = @model.options.merge(path: @model.path + [:[]], parent: @model)
 
       # Don't add if the model is already in the ArrayModel
-      if !@model.cur.array.find {|v| v['_id'] == data['_id'] }
+      if !@model.array.find {|v| v['_id'] == data['_id'] }
         # Find the existing model, or create one
         new_model = @@identity_map.find(data['_id']) { @model.new_model(data.symbolize_keys, new_options, :loaded) }
 
@@ -159,9 +175,9 @@ module Persistors
       @model.path[-1]
     end
 
-
     # When a model is added to this collection, we call its "changed"
     # method.  This should trigger a save.
+    # TODORW:
     def added(model, index)
       if model.persistor
         # Tell the persistor it was added