volt 0.8.27.beta3 → 0.8.27.beta4

data/lib/volt/models/model.rb

@@ -3,10 +3,20 @@ require 'volt/models/array_model'
 require 'volt/models/model_helpers'
 require 'volt/models/model_hash_behaviour'
 require 'volt/models/validations'
-require 'volt/models/model_state'
+require 'volt/utils/modes'
+require 'volt/models/state_manager'
+require 'volt/models/state_helpers'
 require 'volt/models/buffer'
 require 'volt/models/field_helpers'
 require 'volt/reactive/reactive_hash'
+require 'volt/models/validators/user_validation'
+require 'volt/models/dirty'
+require 'volt/models/listener_tracker'
+require 'volt/models/permissions'
+require 'volt/models/associations'
+require 'volt/reactive/class_eventable'
+require 'volt/utils/event_counter'
+require 'thread'
 
 module Volt
   class NilMethodCall < NoMethodError
@@ -21,13 +31,20 @@ module Volt
     include ModelWrapper
     include ModelHelpers
     include ModelHashBehaviour
+    include StateManager
+    include StateHelpers
     include Validations
-    include ModelState
     include Buffer
     include FieldHelpers
+    include UserValidatorHelpers
+    include Dirty
+    include ClassEventable
+    include Modes
+    include ListenerTracker
+    include Permissions
+    include Associations
 
-    attr_reader :attributes
-    attr_reader :parent, :path, :persistor, :options
+    attr_reader :attributes, :parent, :path, :persistor, :options
 
     INVALID_FIELD_NAMES = {
       :attributes => true,
@@ -38,17 +55,49 @@ module Volt
     }
 
     def initialize(attributes = {}, options = {}, initial_state = nil)
+      # The listener event counter keeps track of how many computations are listening on this model
+      @listener_event_counter = EventCounter.new(
+        -> { parent.try(:persistor).try(:listener_added) },
+        -> { parent.try(:persistor).try(:listener_removed) }
+      )
+
+      # The root dependency is used to track if anything is using the data from this
+      # model.  That information is relayed to the ArrayModel so it knows when it can
+      # stop subscribing.
+      # @root_dep    = Dependency.new(@listener_event_counter.method(:add), @listener_event_counter.method(:remove))
+      @root_dep    = Dependency.new(-> { add_list }, -> { remove_list })
+
       @deps        = HashDependency.new
       @size_dep    = Dependency.new
       self.options = options
 
-      send(:attributes=, attributes, true)
+      @new = (initial_state != :loaded)
+
+      assign_attributes(attributes, true)
 
-      # 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
+      # The persistor is usually responsible for setting up the loaded_state, if
+      # there is no persistor, we set it to loaded
+      if @persistor
+        @persistor.loaded(initial_state)
+      else
+        change_state_to(:loaded_state, :loaded, false)
+      end
 
-      @persistor.loaded(initial_state) if @persistor
+      # Trigger the new event, pass in :new
+      trigger!(:new, :new)
+    end
+
+    def add_list
+      @listener_event_counter.add
+    end
+
+    def remove_list
+      @listener_event_counter.remove
+    end
+
+    def state_for(*args)
+      @root_dep.depend
+      super
     end
 
     # the id is stored in a field named _id, so we setup _id to proxy to this
@@ -60,6 +109,11 @@ module Volt
       self.__id = val
     end
 
+    # Return true if the model hasn't been saved yet
+    def new?
+      @new
+    end
+
     # Update the options
     def options=(options)
       @options     = options
@@ -70,31 +124,22 @@ module Volt
     end
 
     # Assign multiple attributes as a hash, directly.
-    def attributes=(attrs, initial_setup = false)
+    def assign_attributes(attrs, initial_setup = false)
       @attributes = {}
 
       attrs = wrap_values(attrs)
 
       if attrs
-        # Assign id first
-        id = attrs.delete(:_id)
-
-        # When doing a mass-assign, we don't save until the end.
-        Model.nosave do
-          self._id = id if id
-
-          # Assign each attribute using setters
-          attrs.each_pair do |key, value|
-            if self.respond_to?(:"#{key}=")
-              # If a method without an underscore is defined, call that.
-              send(:"#{key}=", value)
-            else
-              # Otherwise, use the _ version
-              send(:"_#{key}=", value)
-            end
+        # When doing a mass-assign, we don't validate or save until the end.
+        if initial_setup
+          Model.no_change_tracking do
+            assign_all_attributes(attrs)
           end
+        else
+          assign_all_attributes(attrs)
         end
       else
+        # Assign to nil
         @attributes = attrs
       end
 
@@ -102,18 +147,22 @@ module Volt
       @deps.changed_all!
       @deps = HashDependency.new
 
-      unless initial_setup
+      # Save the changes
+      if initial_setup
+        # Run initial validation
+        errs = Volt.in_mode?(:no_validate) ? nil : validate!
 
-        # Let the persistor know something changed
-        if @persistor
-          # the changed method on a persistor should return a promise that will
-          # be resolved when the save is complete, or fail with a hash of errors.
-          return @persistor.changed
+        if errs && errs.size > 0
+          return Promise.new.reject(errs)
+        else
+          return Promise.new.resolve(nil)
         end
+      else
+        return run_changed
       end
     end
 
-    alias_method :assign_attributes, :attributes=
+    alias_method :attributes=, :assign_attributes
 
     # Pass the comparison through
     def ==(val)
@@ -133,14 +182,13 @@ module Volt
 
     def method_missing(method_name, *args, &block)
       if method_name[0] == '_'
-
         # Remove underscore
         method_name = method_name[1..-1]
         if method_name[-1] == '='
           # Assigning an attribute without the =
-          assign_attribute(method_name[0..-2], *args, &block)
+          set(method_name[0..-2], args[0], &block)
         else
-          read_attribute(method_name)
+          get(method_name)
         end
       else
         # Call on parent
@@ -149,19 +197,21 @@ module Volt
     end
 
     # Do the assignment to a model and trigger a changed event
-    def assign_attribute(method_name, *args, &block)
+    def set(attribute_name, value, &block)
       self.expand!
       # Assign, without the =
-      attribute_name = method_name.to_sym
+      attribute_name = attribute_name.to_sym
 
       check_valid_field_name(attribute_name)
 
-      value = args[0]
-
       old_value = @attributes[attribute_name]
       new_value = wrap_value(value, [attribute_name])
 
       if old_value != new_value
+        # Track the old value, skip if we are in no_validate
+        attribute_will_change!(attribute_name, old_value) unless Volt.in_mode?(:no_change_tracking)
+
+        # Assign the new value
         @attributes[attribute_name] = new_value
 
         @deps.changed!(attribute_name)
@@ -172,13 +222,10 @@ module Volt
 
         # TODO: Can we make this so it doesn't need to be handled for non store collections
         # (maybe move it to persistor, though thats weird since buffers don't have a persistor)
-        clear_server_errors(attribute_name) if @server_errors
+        clear_server_errors(attribute_name) if @server_errors.present?
 
-        # Don't save right now if we're in a nosave block
-        if !defined?(Thread) || !Thread.current['nosave']
-          # Let the persistor know something changed
-          @persistor.changed(attribute_name) if @persistor
-        end
+        # Save the changes
+        run_changed(attribute_name) unless Volt.in_mode?(:no_change_tracking)
       end
     end
 
@@ -186,14 +233,14 @@ module Volt
     # 1) a nil model, which returns a wrapped error
     # 2) reading directly from attributes
     # 3) trying to read a key that doesn't exist.
-    def read_attribute(attr_name)
+    def get(attr_name)
       # Reading an attribute, we may get back a nil model.
       attr_name = attr_name.to_sym
 
       check_valid_field_name(attr_name)
 
-      # Track dependency
-      # @deps.depend(attr_name)
+      # Track that something is listening
+      @root_dep.depend
 
       # See if the value is in attributes
       if @attributes && @attributes.key?(attr_name)
@@ -223,6 +270,10 @@ module Volt
       end
     end
 
+    def respond_to_missing?(method_name, include_private=false)
+      method_name.to_s.start_with?('_') || super
+    end
+
     # Get a new model, make it easy to override
     def read_new_model(method_name)
       if @persistor && @persistor.respond_to?(:read_new_model)
@@ -238,13 +289,13 @@ module Volt
     end
 
     def new_model(attributes, options)
-      class_at_path(options[:path]).new(attributes, options)
+      Volt::Model.class_at_path(options[:path]).new(attributes, options)
     end
 
     def new_array_model(attributes, options)
       # Start with an empty query
       options         = options.dup
-      options[:query] = {}
+      options[:query] = []
 
       ArrayModel.new(attributes, options)
     end
@@ -287,29 +338,43 @@ module Volt
     end
 
     def inspect
-      "<#{self.class}:#{object_id} #{attributes.inspect}>"
+      Computation.run_without_tracking do
+        str = "<#{self.class}:#{object_id}"
+
+        # Get path, loaded_state, and persistor, but cache in local var
+        path = self.path
+        str += " path:#{path}" if path
+
+        loaded_state = self.loaded_state
+        str += " state:#{loaded_state}" if loaded_state
+
+        persistor = self.persistor
+        # str += " persistor:#{persistor.inspect}" if persistor
+        str += " #{attributes.inspect}>"
+
+        str
+      end
     end
 
-    # Takes a block that when run, changes to models will not save inside of
-    if RUBY_PLATFORM == 'opal'
-      # Temporary stub for no save on client
-      def self.nosave
-        yield
+    def destroy
+      if parent
+        result = parent.delete(self)
+
+        # Wrap result in a promise if it isn't one
+        return Promise.new.then { result }
+      else
+        fail "Model does not have a parent and cannot be deleted."
       end
-    else
-      def self.nosave
-        previous = Thread.current['nosave']
-        Thread.current['nosave'] = true
-        begin
-          yield
-        ensure
-          Thread.current['nosave'] = previous
-        end
+    end
+
+    # Setup run mode helpers
+    [:no_save, :no_validate, :no_change_tracking].each do |method_name|
+      define_singleton_method(method_name) do |&block|
+        Volt.run_in_mode(method_name, &block)
       end
     end
 
     private
-
     # Volt provides a few access methods to get more data about the model,
     # we want to prevent these from being assigned or accessed through
     # underscore methods.
@@ -320,8 +385,14 @@ module Volt
     end
 
     def setup_buffer(model)
-      model.attributes = attributes
-      model.change_state_to(:loaded)
+      Volt::Model.no_validate do
+        model.assign_attributes(attributes, true)
+      end
+
+      model.change_state_to(:loaded_state, :loaded)
+
+      # Set new to the same as the main model the buffer is from
+      model.instance_variable_set('@new', @new)
     end
 
     # Takes the persistor if there is one and
@@ -330,5 +401,78 @@ module Volt
         @persistor = persistor.new(self)
       end
     end
+
+    # Used internally from other methods that assign all attributes
+    def assign_all_attributes(attrs)
+      # Assign each attribute using setters
+      attrs.each_pair do |key, value|
+        key = key.to_sym
+
+        # Track the change, since assign_all_attributes runs with no_change_tracking
+        # attribute_will_change!(key, @attributes[key])
+
+        if self.respond_to?(:"#{key}=")
+          # If a method without an underscore is defined, call that.
+          send(:"#{key}=", value)
+        else
+          # Otherwise, use the _ version
+          send(:"_#{key}=", value)
+        end
+      end
+    end
+
+    # Called when something in the model changes.  Saves
+    # the model if there is a persistor, and changes the
+    # model to not be new.
+    #
+    # @return [Promise|nil] a promise for when the save is
+    #         complete
+    def run_changed(attribute_name=nil)
+      result = nil
+
+      # no_validate mode should only be used internally.  no_validate mode is a
+      # performance optimization that prevents validation from running after each
+      # change when assigning multile attributes.
+      unless Volt.in_mode?(:no_validate)
+        # Run the validations for all fields
+        validate!
+
+        # Buffers are allowed to be in an invalid state
+        unless buffer?
+          # First check that all local validations pass
+          if error_in_changed_attributes?
+            # Some errors are present, revert changes
+            revert_changes!
+
+            # After we revert, we need to validate again to get the error messages back
+            # TODO: Could probably cache the previous errors.
+            errs = validate!
+
+            result = Promise.new.reject(errs)
+          else
+            # No errors, tell the persistor to handle the change (usually save)
+
+            # Don't save right now if we're in a nosave block
+            unless Volt.in_mode?(:no_save)
+              # the changed method on a persistor should return a promise that will
+              # be resolved when the save is complete, or fail with a hash of errors.
+              if @persistor
+                result = @persistor.changed(attribute_name)
+              else
+                result = Promise.new.resolve(nil)
+              end
+
+              # Saved, no longer new
+              @new = false
+
+              # Clear the change tracking
+              clear_tracked_changes!
+            end
+          end
+        end
+      end
+
+      return result
+    end
   end
 end

data/lib/volt/models/model_helpers.rb

@@ -21,29 +21,39 @@ module Volt
       @persistor.event_removed(event, last, last_for_event) if @persistor
     end
 
-    # Gets the class for a model at the specified path.
-    def class_at_path(path)
-      if path
-        begin
-          # remove the _ and then singularize
-          if path.last == :[]
-            index = -2
-          else
-            index = -1
-          end
+    module ClassMethods
+      # Gets the class for a model at the specified path.
+      def class_at_path(path)
+        if path
+          begin
+            # remove the _ and then singularize
+            if path.last == :[]
+              index = -2
+            else
+              index = -1
+            end
+
+            klass_name = path[index].singularize.camelize
 
-          klass_name = path[index].singularize.camelize
+            # Lookup the class
+            klass = Object.const_get(klass_name)
 
-          klass = $page.model_classes[klass_name] || Model
-        rescue NameError => e
-          # Ignore exception, just means the model isn't defined
+            # Use it if it is a model
+            klass = Model unless klass < Model
+          rescue NameError => e
+            # Ignore exception, just means the model isn't defined
+            klass = Model
+          end
+        else
           klass = Model
         end
-      else
-        klass = Model
+
+        klass
       end
+    end
 
-      klass
+    def self.included(base)
+      base.send :extend, ClassMethods
     end
   end
 end