volt 0.9.2 → 0.9.3.pre1

data/lib/volt/models/array_model.rb

@@ -1,8 +1,9 @@
 require 'volt/reactive/reactive_array'
 require 'volt/models/model_wrapper'
-require 'volt/models/model_helpers'
+require 'volt/models/model_helpers/model_helpers'
 require 'volt/models/state_manager'
 require 'volt/models/state_helpers'
+require 'volt/data_stores/data_store'
 
 module Volt
   class ArrayModel < ReactiveArray
@@ -40,7 +41,7 @@ module Volt
     end
 
     proxy_with_root_dep :[], :size, :first, :last, :state_for, :reverse
-    proxy_to_persistor :find, :where, :skip, :sort, :limit, :then, :fetch, :fetch_first, :fetch_each
+    proxy_to_persistor :then, :fetch, :fetch_first, :fetch_each
 
     def initialize(array = [], options = {})
       @options   = options

data/lib/volt/models/model.rb

@@ -1,8 +1,8 @@
 require 'volt/models/model_wrapper'
 require 'volt/models/array_model'
-require 'volt/models/model_helpers'
+require 'volt/models/model_helpers/model_helpers'
 require 'volt/models/model_hash_behaviour'
-require 'volt/models/validations'
+require 'volt/models/validations/validations'
 require 'volt/utils/modes'
 require 'volt/models/state_manager'
 require 'volt/models/state_helpers'
@@ -10,8 +10,9 @@ 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/model_helpers/dirty'
+require 'volt/models/model_helpers/listener_tracker'
+require 'volt/models/model_helpers/model_change_helpers'
 require 'volt/models/permissions'
 require 'volt/models/associations'
 require 'volt/reactive/class_eventable'
@@ -45,6 +46,7 @@ module Volt
     include Permissions
     include Associations
     include ReactiveAccessors
+    include ModelChangeHelpers
 
     attr_reader :attributes, :parent, :path, :persistor, :options
 
@@ -149,24 +151,7 @@ module Volt
       @deps.changed_all!
       @deps = HashDependency.new
 
-      # Save the changes
-      if initial_setup
-        # Run initial validation
-        if Volt.in_mode?(:no_validate)
-          # No validate, resolve nil
-          Promise.new.resolve(nil)
-        else
-          return validate!.then do |errs|
-            if errs && errs.size > 0
-              Promise.new.reject(errs)
-            else
-              Promise.new.resolve(nil)
-            end
-          end
-        end
-      else
-        return run_changed
-      end
+      run_initial_setup(initial_setup)
     end
 
     alias_method :attributes=, :assign_attributes
@@ -353,6 +338,28 @@ module Volt
     end
 
     private
+    def run_initial_setup(initial_setup)
+
+      # Save the changes
+      if initial_setup
+        # Run initial validation
+        if Volt.in_mode?(:no_validate)
+          # No validate, resolve nil
+          Promise.new.resolve(nil)
+        else
+          return validate!.then do |errs|
+            if errs && errs.size > 0
+              Promise.new.reject(errs)
+            else
+              Promise.new.resolve(nil)
+            end
+          end
+        end
+      else
+        return run_changed
+      end
+    end
+
 
     # Volt provides a few access methods to get more data about the model,
     # we want to prevent these from being assigned or accessed through
@@ -363,17 +370,6 @@ module Volt
       end
     end
 
-    def setup_buffer(model)
-      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
     def setup_persistor(persistor)
       @persistor = persistor.new(self) if persistor
@@ -398,63 +394,5 @@ module Volt
         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)
-      # 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
-        result = nil
-        return validate!.then do
-          # 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.
-              result = validate!.then do
-                # Reject the promise with the errors
-                Promise.new.reject(errs)
-              end
-            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
-
-          # Return result inside of the validate! promise
-          result
-        end
-      end
-
-      # Didn't run validations
-      nil
-    end
   end
 end

data/lib/volt/models/model_helpers/model_change_helpers.rb

@@ -0,0 +1,76 @@
+# ModelChangeHelpers handle validating and persisting the data in a model
+# when it is changed.  #run_changed will be called from the model.
+
+module Volt
+  module ModelChangeHelpers
+    private
+
+    # 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)
+      # 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
+        result = nil
+        return validate!.then do
+          # 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.
+              result = validate!.then do
+                # Reject the promise with the errors
+                Promise.new.reject(errs)
+              end
+            else
+              result = persist_changes(attribute_name)
+            end
+          end
+
+          # Return result inside of the validate! promise
+          result
+        end
+      end
+
+      # Didn't run validations
+      nil
+    end
+
+
+    # Should only be called from run_changed.  Saves the changes back to the persistor
+    # and clears the tracked changes.
+    def persist_changes(attribute_name)
+      # 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
+
+      result
+    end
+
+  end
+end

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

@@ -1,6 +1,5 @@
 require 'volt/models/persistors/store'
 require 'volt/models/persistors/store_state'
-require 'volt/models/persistors/query/normalizer'
 require 'volt/models/persistors/query/query_listener_pool'
 require 'volt/utils/timers'
 
@@ -9,6 +8,7 @@ module Volt
     class ArrayStore < Store
       include StoreState
 
+
       @@query_pool = QueryListenerPool.new
 
       attr_reader :model, :root_dep
@@ -141,7 +141,7 @@ module Volt
           end
         end
 
-        query = Query::Normalizer.normalize(query)
+        query = Volt::DataStore.adaptor_client.normalize_query(query)
 
         @query_listener ||= @@query_pool.lookup(collection, query) do
           # Create if it does not exist
@@ -153,27 +153,6 @@ module Volt
         @query_listener
       end
 
-      # Find takes a query object
-      def where(query = nil)
-        query ||= {}
-
-        add_query_part(:find, query)
-      end
-      alias_method :find, :where
-
-      def limit(limit)
-        add_query_part(:limit, limit)
-      end
-
-      def skip(skip)
-        add_query_part(:skip, skip)
-      end
-
-      # .sort is already a ruby method, so we use order instead
-      def order(sort)
-        add_query_part(:sort, sort)
-      end
-
       # Add query part adds a [method_name, *arguments] array to the query.
       # This will then be passed to the backend to run the query.
       #

data/lib/volt/models/persistors/query/normalizer.rb

@@ -2,50 +2,6 @@ module Volt
   module Query
     # Normalizes queries so queries that are the same have the same order and parts
     class Normalizer
-      def self.normalize(query)
-        query = merge_finds_and_move_to_front(query)
-
-        query = reject_skip_zero(query)
-
-        query
-      end
-
-      def self.merge_finds_and_move_to_front(query)
-        # Map first parts to string
-        query = query.map { |v| v[0] = v[0].to_s; v }
-        has_find = query.find { |v| v[0] == 'find' }
-
-        if has_find
-          # merge any finds
-          merged_find_query = {}
-          query = query.reject do |query_part|
-            if query_part[0] == 'find'
-              # on a find, merge into finds
-              find_query = query_part[1]
-              merged_find_query.merge!(find_query) if find_query
-
-              # reject
-              true
-            else
-              false
-            end
-          end
-
-          # Add finds to the front
-          query.insert(0, ['find', merged_find_query])
-        else
-          # No find was done, add it in the first position
-          query.insert(0, ['find'])
-        end
-
-        query
-      end
-
-      def self.reject_skip_zero(query)
-        query.reject do |query_part|
-          query_part[0] == 'skip' && query_part[1] == 0
-        end
-      end
     end
   end
 end

data/lib/volt/models/{validations.rb → validations/validations.rb}

@@ -11,6 +11,8 @@ module Volt
   # Include in any class to get validation logic
   module Validations
     module ClassMethods
+      # Validate is called directly on the class and sets up the validation to be run
+      # each time validate! is called on the class.
       def validate(field_name = nil, options = nil, &block)
         if block
           if field_name || options
@@ -19,16 +21,47 @@ module Volt
           self.custom_validations ||= []
           custom_validations << block
         else
-          self.validations ||= {}
-          validations[field_name] ||= {}
-          validations[field_name].merge!(options)
+          self.validations_to_run ||= {}
+          validations_to_run[field_name] ||= {}
+          validations_to_run[field_name].merge!(options)
         end
       end
+
+      # Validations takes a block, and can contain validate calls inside of it
+      # which will conditionally be run based on the code in the block.  The
+      # context of the block will be the current model.
+      def validations(*run_in_actions, &block)
+        unless block_given?
+          raise 'validations must take a block, use `validate` to setup a validation on a class directly.'
+        end
+
+        # Add a validation block to run during each validation
+        validate do
+          action = new? ? :create : :update
+
+          if run_in_actions.size == 0 || run_in_actions.include?(action)
+            @instance_validations = {}
+
+            instance_exec(action, &block)
+
+            result = run_validations(@instance_validations)
+
+            @instance_validations = nil
+
+            result
+          end
+        end
+      end
+    end
+
+    def validate(field_name = nil, options = nil)
+      @instance_validations[field_name] ||= {}
+      @instance_validations[field_name].merge!(options)
     end
 
     def self.included(base)
       base.send :extend, ClassMethods
-      base.class_attribute(:custom_validations, :validations)
+      base.class_attribute(:custom_validations, :validations_to_run)
     end
 
     # Once a field is ready, we can use include_in_errors! to start
@@ -43,11 +76,21 @@ module Volt
 
     # Marks all fields, useful for when a model saves.
     def mark_all_fields!
-      validations = self.class.validations
+      # TODO: We can use a Set here, but set was having issues.  Check in a
+      # later version of opal.
+      fields_to_mark = []
+
+      # Look at each validation
+      validations = self.class.validations_to_run
       if validations
-        validations.each_key do |key|
-          mark_field!(key.to_sym)
-        end
+        fields_to_mark += validations.keys
+      end
+
+      # Also include any current fields
+      fields_to_mark += attributes.keys
+
+      fields_to_mark.each do |key|
+        mark_field!(key.to_sym)
       end
     end
 
@@ -110,31 +153,42 @@ module Volt
     private
 
     # Runs through each of the normal validations.
+    # @param [Array] An array of validations to run
     # @return [Promise] a promsie to run all validations
-    def run_validations
-      promise = Promise.new.resolve(nil)
+    def run_validations(validations = nil)
+      # Default to running the class level validations
+      validations ||= self.class.validations_to_run
 
-      validations = self.class.validations
+      promise = Promise.new.resolve(nil)
       if validations
 
         # Run through each validation
         validations.each_pair do |field_name, options|
-          options.each_pair do |validation, args|
-            # Call the specific validator, then merge the results back
-            # into one large errors hash.
-            klass = validation_class(validation, args)
-
-            if klass
-              # Chain on the promises
-              promise = promise.then do
-                klass.validate(self, field_name, args)
-              end.then do |errs|
-                errors.merge!(errs)
-              end
-            else
-              fail "validation type #{validation} is not specified."
-            end
+          promise = promise.then { run_validation(field_name, options) }
+        end
+      end
+
+      promise
+    end
+
+    # Runs an individual validation
+    # @returns [Promise]
+    def run_validation(field_name, options)
+      promise = Promise.new.resolve(nil)
+      options.each_pair do |validation, args|
+        # Call the specific validator, then merge the results back
+        # into one large errors hash.
+        klass = validation_class(validation, args)
+
+        if klass
+          # Chain on the promises
+          promise = promise.then do
+            klass.validate(self, field_name, args)
+          end.then do |errs|
+            errors.merge!(errs)
           end
+        else
+          fail "validation type #{validation} is not specified."
         end
       end