volt 0.9.4.pre3 → 0.9.4.pre5

data/lib/volt/models/buffer.rb

@@ -1,3 +1,5 @@
+require 'volt/reactive/reactive_accessors'
+
 module Volt
   module Buffer
     # Save saves the contents of a buffer to the save_to location.  If the buffer is new, it will create a new
@@ -14,7 +16,8 @@ module Volt
         result = nil
 
         if errors.size == 0
-          save_to = options[:save_to]
+          # cache save_to in a local
+          save_to = self.save_to
           if save_to
             if save_to.is_a?(ArrayModel)
               # Add to the collection
@@ -33,7 +36,7 @@ module Volt
                 new_model.change_state_to(:loaded_state, :loaded)
 
                 # Set the buffer's id to track the main model's id
-                options[:save_to] = new_model
+                self.save_to = new_model
               end
 
               # Copy attributes back from save_to model
@@ -76,11 +79,7 @@ module Volt
     end
 
     def buffer?
-      options[:buffer]
-    end
-
-    def save_to
-      options[:save_to]
+      options[:buffer] || false
     end
 
     # Returns a buffered version of the model
@@ -100,5 +99,41 @@ module Volt
 
       model
     end
+
+    def self.included(base)
+      base.include ReactiveAccessors
+      base.reactive_accessor :__save_to
+    end
+
+    def save_to
+      val = __save_to
+
+      unless val
+        # Lazy load the save_to
+        self.save_to = options[:save_to]
+        return __save_to
+      end
+
+      val
+    end
+
+    def save_to=(val)
+      self.__save_to = val
+    end
+
+    def saved_state
+      if buffer?
+        # cache save_to in local
+        lsave_to = self.save_to
+
+        lsave_to.try(:saved_state) || :not_saved
+      else
+        super
+      end
+    end
+
+    def saved?
+      saved_state == :saved
+    end
   end
 end

data/lib/volt/models/helpers/array_model.rb

@@ -0,0 +1,15 @@
+module Volt
+  module Models
+    module Helpers
+      module ArrayModel
+        def loaded_state
+          state_for(:loaded_state)
+        end
+
+        def loaded?
+          loaded_state == :loaded
+        end
+      end
+    end
+  end
+end

data/lib/volt/models/helpers/base.rb

@@ -0,0 +1,113 @@
+module Volt
+  module Models
+    module Helpers
+      # A place for things shared between an ArrayModel and a Model
+      module Base
+        def deep_unwrap(value)
+          if value.is_a?(Model)
+            value.to_h
+          elsif value.is_a?(ArrayModel)
+            value.to_a
+          else
+            value
+          end
+        end
+
+        # Pass to the persisotr
+        def event_added(event, first, first_for_event)
+          @persistor.event_added(event, first, first_for_event) if @persistor
+        end
+
+        # Pass to the persistor
+        def event_removed(event, last, last_for_event)
+          @persistor.event_removed(event, last, last_for_event) if @persistor
+        end
+
+        ID_CHARS = [('a'..'f'), ('0'..'9')].map(&:to_a).flatten
+
+        # Create a random unique id that can be used as the mongo id as well
+        def generate_id
+          id = []
+          24.times { id << ID_CHARS.sample }
+
+          id.join
+        end
+
+
+        # Return the attributes that are only for this model and any hash sub models
+        # but not any sub-associations.
+        def self_attributes
+          # Don't store any sub-models, those will do their own saving.
+          attributes.reject { |k, v| v.is_a?(ArrayModel) }.map do |k,v|
+            if v.is_a?(Model)
+              v = v.self_attributes
+            end
+
+            [k,v]
+          end.to_h
+        end
+
+
+        # Takes the persistor if there is one and
+        def setup_persistor(persistor)
+          # Use page as the default persistor
+          persistor ||= Persistors::Page
+          if persistor.respond_to?(:new)
+            @persistor = persistor.new(self)
+          else
+            # an already initialized persistor was passed in
+            @persistor = persistor
+          end
+        end
+
+        def store
+          Volt.current_app.store
+        end
+
+        # returns the root model for the collection the model is currently on.  So
+        # if the model is persisted somewhere on store, it will return ```store```
+        def root
+          persistor.try(:root_model)
+        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/pluralize
+                if path.last == :[]
+                  index = -2
+                else
+                  index = -1
+                end
+
+                # process_class_name is defined by Model/ArrayModel as
+                # singularize/pluralize
+                klass_name = process_class_name(klass_name = path[index]).camelize
+
+                # Lookup the class
+                klass = Object.const_get(klass_name)
+
+                # Use it if it is a model
+                klass = self unless klass < self
+              rescue NameError => e
+                # Ignore exception, just means the model isn't defined
+                klass = self
+              end
+            else
+              klass = self
+            end
+
+            klass
+          end
+        end
+
+        def self.included(base)
+          base.send :extend, ClassMethods
+        end
+
+      end
+    end
+  end
+end

data/lib/volt/models/helpers/change_helpers.rb

@@ -0,0 +1,91 @@
+# 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 Models
+    module Helpers
+      module ChangeHelpers
+        def self.included(base)
+          base.setup_action_helpers_in_class(:before_save, :before_validate)
+        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
+                  result = persist_changes(attribute_name)
+                end
+              end
+
+              # Return result inside of the validate! promise
+              result.then { self }
+            end
+          end
+
+          # Didn't run validations
+          self.then
+        end
+
+
+        private
+        # 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)
+          result = nil
+
+          # Don't save right now if we're in a nosave block
+          unless Volt.in_mode?(:no_save)
+            # Call the before_save callback
+            # skip validations when running before_save, this prevents n+1, and allows
+            # the before_save to put the model into an invalid state, which you want
+            # sometimes.
+            Volt::Model.no_validate do
+              run_callbacks(:before_save)
+            end
+
+            # 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
+  end
+end

data/lib/volt/models/helpers/dirty.rb

@@ -0,0 +1,93 @@
+module Volt
+  module Models
+    module Helpers
+      # The dirty module provides helper methods for working with and tracking
+      # previous values on model attributes.
+      module Dirty
+        # Return the list of attributes that have changed since the last 'save' event.
+        def changed_attributes
+          @changed_attributes ||= {}
+        end
+
+        # Return true if key has changed
+        def changed?(key = nil)
+          if key
+            # return the changed values for the keys
+            changed_attributes.key?(key)
+          else
+            changed_attributes.present?
+          end
+        end
+
+        # Grab all previous versions of for key
+        def changes(key)
+          changed_attributes[key]
+        end
+
+        # Grab the previous value for the key
+        def was(key)
+          val = changed_attributes[key]
+
+          # Doing val && val[0] doesn't work in opal
+          # https://github.com/opal/opal/issues/664
+          if val
+            val[0]
+          else
+            nil
+          end
+        end
+
+        # Clear changed attributes
+        def clear_tracked_changes!
+          @changed_attributes = {}
+        end
+
+        # Reverts the model attributes back to the pre-change values.
+        def revert_changes!
+          # Reassign the first value since we started tracking
+          if @changed_attributes
+            @changed_attributes.each_pair do |key, value|
+              @attributes[key] = value.first
+            end
+          end
+
+          clear_tracked_changes!
+        end
+
+        def attribute_will_change!(attribute_name, old_value)
+          # Don't track nil models
+          old_value = nil if old_value.nil?
+
+          (changed_attributes[attribute_name] ||= []) << old_value
+        end
+
+        # Handle change and was method calls
+        # Example: name_was or name_changes
+        def method_missing(method_name, *args, &block)
+          # Quick check to see if changes or was are being called, this check
+          # keeps us from needing to parse out the parts if we're not going
+          # to use them.
+          if method_name =~ /[_](changes|was)$/
+            # Break apart the method call
+            # TODO: no destructuring because of https://github.com/opal/opal/issues/663
+            *parts = method_name.to_s.split('_')
+            action = parts.pop
+            key = parts.join('_').to_sym
+
+            # Handle changes or was calls.
+            case action
+            when 'changes'
+              return changes(key)
+            when 'was'
+              return was(key)
+            end
+          end
+
+          # Otherwise, run super
+          super
+        end
+      end
+    end
+
+  end
+end

data/lib/volt/models/helpers/listener_tracker.rb

@@ -0,0 +1,19 @@
+module Volt
+  module Models
+    module Helpers
+      # Included in model's so they can inform the ArrayModel when new listeners are added or removed.
+      module ListenerTracker
+        # Called when data from this model begins being watched
+        def listener_added
+          @listener_count ||= 0
+          @listener_count += 1
+        end
+
+        def listener_removed
+          @listener_count ||= 0
+          @listener_count -= 1
+        end
+      end
+    end
+  end
+end

data/lib/volt/models/helpers/model.rb

@@ -0,0 +1,15 @@
+module Volt
+  module Models
+    module Helpers
+      module Model
+        def saved_state
+          state_for(:saved_state) || :saved
+        end
+
+        def saved?
+          saved_state == :saved
+        end
+      end
+    end
+  end
+end

data/lib/volt/models/model.rb

@@ -1,18 +1,18 @@
 require 'volt/models/model_wrapper'
 require 'volt/models/array_model'
-require 'volt/models/model_helpers/model_helpers'
+require 'volt/models/helpers/base'
 require 'volt/models/model_hash_behaviour'
 require 'volt/models/validations/validations'
 require 'volt/utils/modes'
 require 'volt/models/state_manager'
-require 'volt/models/state_helpers'
+require 'volt/models/helpers/model'
 require 'volt/models/buffer'
 require 'volt/models/field_helpers'
 require 'volt/reactive/reactive_hash'
 require 'volt/models/validators/user_validation'
-require 'volt/models/model_helpers/dirty'
-require 'volt/models/model_helpers/listener_tracker'
-require 'volt/models/model_helpers/model_change_helpers'
+require 'volt/models/helpers/dirty'
+require 'volt/models/helpers/listener_tracker'
+require 'volt/models/helpers/change_helpers'
 require 'volt/models/permissions'
 require 'volt/models/associations'
 require 'volt/reactive/class_eventable'
@@ -33,22 +33,23 @@ module Volt
   class Model
     include LifecycleCallbacks
     include ModelWrapper
-    include ModelHelpers
+    include Models::Helpers::Base
     include ModelHashBehaviour
     include StateManager
-    include StateHelpers
+    include Models::Helpers::Model
     include Validations
+    # Buffer needs to go after StateHelpers so it can call saved_state as super
     include Buffer
     include FieldHelpers
     include UserValidatorHelpers
-    include Dirty
+    include Models::Helpers::Dirty
     include ClassEventable
     include Modes
-    include ListenerTracker
+    include Models::Helpers::ListenerTracker
     include Permissions
     include Associations
     include ReactiveAccessors
-    include ModelChangeHelpers
+    include Models::Helpers::ChangeHelpers
 
     attr_reader :attributes, :parent, :path, :persistor, :options
 
@@ -305,7 +306,7 @@ module Volt
       options         = options.dup
       options[:query] = []
 
-      ArrayModel.new(attributes, options)
+      Volt::ArrayModel.class_at_path(options[:path]).new(attributes, options)
     end
 
     def inspect
@@ -336,7 +337,7 @@ module Volt
         result = parent.delete(self)
 
         # Wrap result in a promise if it isn't one
-        return result.then
+        return result#.then
       else
         fail 'Model does not have a parent and cannot be deleted.'
       end
@@ -416,5 +417,9 @@ module Volt
       end
     end
 
+    def self.process_class_name(name)
+      name.singularize
+    end
+
   end
 end

data/lib/volt/models/permissions.rb

@@ -23,7 +23,7 @@ module Volt
             end
           end
 
-          on(:create, :update) do
+          permissions(:update) do
             # Don't allow the key to be changed
             deny(key)
           end

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

@@ -309,6 +309,10 @@ module Volt
           @ids.delete(model.id)
         end
       end
+
+      def async?
+        true
+      end
     end
   end
 end

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

@@ -10,6 +10,10 @@ module Volt
         @model.change_state_to(:loaded_state, initial_state || :loaded)
       end
 
+      # Method that is called when data on the model changes.
+      # @returns [true|Promise] - should return a Promise or true.  On async
+      #    persistors, the promise from set and save! will wait on the
+      #    Promise.
       def changed(attribute_name)
       end
 
@@ -36,6 +40,12 @@ module Volt
         false
       end
 
+      # return true if this persistor is asynchronus and needs to return
+      # Promises.
+      def async?
+        false
+      end
+
       # Find the root for this model
       def root_model
         node = @model

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

@@ -76,6 +76,8 @@ module Volt
           # Temp, expire in 1 year, going to expand this api
           write_cookie(attribute_name, value.to_s, expires: Time.now + (356 * 24 * 60 * 60), path: '/')
         end
+
+        true
       end
 
       def removed(attribute_name)

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

@@ -12,6 +12,7 @@ module Volt
       end
 
       def loaded(initial_state = nil)
+        super
         # When the main model is first loaded, we pull in the data from the
         # store if it exists
         if @model.path == []
@@ -31,6 +32,8 @@ module Volt
       # Callled when an item is changed (or removed)
       def changed(attribute_name)
         root_model.persistor.save_all
+
+        true
       end
 
       # Called on the root

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

@@ -103,14 +103,21 @@ module Volt
         delete self.saveTimer;
         `
 
+        @model.change_state_to(:saved_state, :saving)
+
         StoreTasks.save(collection, @model.path, self_attributes).then do
           save_promises = @save_promises
           @save_promises = nil
           save_promises.each { |promise|  promise.resolve(nil) }
+
+          @model.change_state_to(:saved_state, :saved)
         end.fail do |errors|
           save_promises = @save_promises
           @save_promises = nil
           save_promises.each { |promise|  promise.reject(errors) }
+
+          # Mark that we failed to save
+          @model.change_state_to(:saved_state, :save_failed)
         end
       end
 

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

@@ -13,11 +13,14 @@ module Volt
               window.paramsUpdateTimer = setTimeout(this.$run_update.bind(this), 0);
             }
           `
+
         end
+
+        true
       end
 
       def run_update
-        $page.url.update! if Volt.client?
+        Volt.current_app.url.update! if Volt.client?
       end
     end
   end

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

@@ -49,7 +49,7 @@ module Volt
         # If we get back that the user signature is wrong, log the user out.
         if err.to_s.start_with?('user id or hash is incorrectly signed')
           # Delete the invalid cookie
-          $page.cookies.delete(:user_id)
+          Volt.current_app.cookies.delete(:user_id)
         end
 
         fail err

data/lib/volt/models/url.rb

@@ -123,15 +123,20 @@ module Volt
         frag = fragment
         if frag.present?
           # Scroll to anchor via http://www.w3.org/html/wg/drafts/html/master/browsers.html#scroll-to-fragid
+          # Sometimes the fragment will cause a jquery parsing error, so we
+          # catch any exceptions.
           `
-          var anchor = $('#' + frag);
-          if (anchor.length == 0) {
-            anchor = $('*[name="' + frag + '"]:first');
-          }
-          if (anchor && anchor.length > 0) {
-            console.log('scroll to: ', anchor.offset().top);
-            $(document.body).scrollTop(anchor.offset().top);
+          try {
+            var anchor = $('#' + frag);
+            if (anchor.length == 0) {
+              anchor = $('*[name="' + frag + '"]:first');
+            }
+            if (anchor && anchor.length > 0) {
+              console.log('scroll to: ', anchor.offset().top);
+              $(document.body).scrollTop(anchor.offset().top);
+            }
           }
+          catch(e) {}
         `
         else
           # Scroll to the top by default

data/lib/volt/models/validators/unique_validator.rb

@@ -12,7 +12,7 @@ module Volt
 
           # Check if the value is taken
           # TODO: need a way to handle scope for unique
-          return $page.store.get(model.path[-2]).where(query).first.then do |item|
+          return Volt.current_app.store.get(model.path[-2]).where(query).first.then do |item|
             if item
               message = (args.is_a?(Hash) && args[:message]) || 'is already taken'
 

data/lib/volt/page/bindings/base_binding.rb

@@ -21,8 +21,8 @@ module Volt
       @@binding_number ||= 10_000
     end
 
-    def page
-      @volt_app.page
+    def browser
+      @volt_app.browser
     end
 
     def dom_section