volt 0.8.27.beta3 → 0.8.27.beta4

data/lib/volt/extra_core/object.rb

@@ -30,7 +30,11 @@ class Object
 
   # TODO: Need a real implementation of this
   def deep_clone
-    Marshal.load(Marshal.dump(self))
+    if RUBY_PLATFORM == 'opal'
+      JSON.parse(self.to_json)
+    else
+      Marshal.load(Marshal.dump(self))
+    end
   end
 
   def try(*a, &b)

data/lib/volt/models/array_model.rb

@@ -1,22 +1,27 @@
 require 'volt/reactive/reactive_array'
 require 'volt/models/model_wrapper'
 require 'volt/models/model_helpers'
-require 'volt/models/model_state'
+require 'volt/models/state_manager'
+require 'volt/models/state_helpers'
 
 module Volt
   class ArrayModel < ReactiveArray
     include ModelWrapper
     include ModelHelpers
-    include ModelState
+    include StateManager
+    include StateHelpers
+
 
     attr_reader :parent, :path, :persistor, :options, :array
 
     # For many methods, we want to call load data as soon as the model is interacted
     # with, so we proxy the method, then call super.
-    def self.proxy_with_load_data(*method_names)
+    def self.proxy_with_root_dep(*method_names)
       method_names.each do |method_name|
         define_method(method_name) do |*args|
-          load_data
+          # track on the root dep
+          persistor.try(:root_dep).try(:depend)
+
           super(*args)
         end
       end
@@ -35,8 +40,8 @@ module Volt
       end
     end
 
-    proxy_with_load_data :[], :size, :first, :last
-    proxy_to_persistor :find, :skip, :limit, :then
+    proxy_with_root_dep :[], :size, :first, :last, :state_for#, :limit, :find_one, :find
+    proxy_to_persistor :find, :where, :skip, :sort, :limit, :then, :fetch, :fetch_first
 
     def initialize(array = [], options = {})
       @options   = options
@@ -48,7 +53,11 @@ module Volt
 
       super(array)
 
-      @persistor.loaded if @persistor
+      if @persistor
+        @persistor.loaded
+      else
+        change_state_to(:loaded_state, :loaded, false)
+      end
     end
 
     def attributes
@@ -57,8 +66,6 @@ module Volt
 
     # Make sure it gets wrapped
     def <<(model)
-      load_data
-
       if model.is_a?(Model)
         # Set the new path
         model.options = @options.merge(path: @options[:path] + [:[]])
@@ -66,23 +73,48 @@ module Volt
         model = wrap_values([model]).first
       end
 
+      if model.is_a?(Model) && !model.can_create?
+        raise "permissions did not allow create for #{model.inspect}"
+      end
+
       super(model)
 
       if @persistor
-        @persistor.added(model, @array.size - 1)
+        promise = @persistor.added(model, @array.size - 1)
+        if promise && promise.is_a?(Promise)
+          return promise.fail do |err|
+            # remove from the collection because it failed to save on the server
+            @array.delete(model)
+
+            # TODO: the model might be in at a different position already, so we should use a full delete
+            trigger_removed!(@array.size - 1)
+            trigger_size_change!
+            #
+            # re-raise, err might not be an Error object, so we use a rejected promise to re-raise
+            Promise.new.reject(err)
+          end
+        end
       else
         nil
       end
     end
 
-    # Works like << except it returns a promise
+    # Works like << except it always returns a promise
     def append(model)
-      promise, model = send(:<<, model)
-
-      # Return a promise if one doesn't exist
-      promise ||= Promise.new.resolve(model)
+      # Wrap results in a promise
+      Promise.new.resolve(nil).then do
+        send(:<<, model)
+      end
+    end
 
-      promise
+    def delete(val)
+      # Check to make sure the models are allowed to be deleted
+      if !val.is_a?(Model) || val.can_delete?
+        result = super
+        Promise.new.resolve(result)
+      else
+        Promise.new.reject("permissions did not allow delete for #{val.inspect}.")
+      end
     end
 
     # Find one does a query, but only returns the first item or
@@ -92,6 +124,32 @@ module Volt
       find(*args, &block).limit(1)[0]
     end
 
+    def first
+      self[0]
+    end
+
+    # returns a promise to fetch the first instance
+    def fetch_first(&block)
+      persistor = self.persistor
+
+      if persistor && persistor.is_a?(Persistors::ArrayStore)
+        # On array store, we wait for the result to be loaded in.
+        promise = limit(1).fetch do |res|
+          result = res.first
+
+          next result
+        end
+      else
+        # On all other persistors, it should be loaded already
+        promise = Promise.new.resolve(first)
+      end
+
+      # Run any passed in blocks after fetch
+      promise = promise.then(&block) if block
+
+      promise
+    end
+
     # Make sure it gets wrapped
     def inject(*args)
       args = wrap_values(args)
@@ -105,7 +163,7 @@ module Volt
     end
 
     def new_model(*args)
-      class_at_path(options[:path]).new(*args)
+      Volt::Model.class_at_path(options[:path]).new(*args)
     end
 
     def new_array_model(*args)
@@ -122,23 +180,23 @@ module Volt
     end
 
     def inspect
-      # Just load the data on the server making it easier to work with
-      load_data if Volt.server?
-
-      if @persistor && @persistor.is_a?(Persistors::ArrayStore) && state == :not_loaded
-        # Show a special message letting users know it is not loaded yet.
-        "#<#{self.class}:not loaded, access with [] or size to load>"
-      else
-        # Otherwise inspect normally
-        super
+      Computation.run_without_tracking do
+        # Track on size
+        @size_dep.depend
+        str = "#<#{self.class}:#{object_id} #{loaded_state}"
+        str += " path:#{path.join('.')}" if path
+        # str += " persistor:#{persistor.inspect}" if persistor
+        str += " #{@array.inspect}>"
+
+        str
       end
     end
 
     def buffer
       model_path  = options[:path] + [:[]]
-      model_klass = class_at_path(model_path)
+      model_klass = Volt::Model.class_at_path(model_path)
 
-      new_options = options.merge(path: model_path, save_to: self).reject { |k, _| k.to_sym == :persistor }
+      new_options = options.merge(path: model_path, save_to: self, buffer: true).reject { |k, _| k.to_sym == :persistor }
       model       = model_klass.new({}, new_options)
 
       model
@@ -152,12 +210,5 @@ module Volt
         @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/associations.rb

@@ -0,0 +1,53 @@
+module Volt
+  module Associations
+    module ClassMethods
+      def belongs_to(method_name, key_name=nil)
+        define_method(method_name) do
+          association_with_root_model('belongs_to') do |root|
+            # Lookup the associated model id
+            lookup_key = send(:"_#{key_name || method_name}_id")
+
+            # Return a promise for the belongs_to
+            root.send(:"_#{method_name.pluralize}").where(:_id => lookup_key).fetch_first
+          end
+        end
+      end
+
+      def has_many(method_name, remote_key_name=nil)
+        define_method(method_name) do
+          association_with_root_model('has_many') do |root|
+            id = self._id
+
+            # The key will be "{this class name}_id"
+            remote_key_name ||= :"#{path[-2].singularize}_id"
+
+            root.send(:"_#{method_name.pluralize}").where(remote_key_name => id)
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    private
+    # Currently the has_many and belongs_to associations only work on the store collection,
+    # this method checks to make sure we are on store and returns the root reference to it.
+    def association_with_root_model(method_name)
+      persistor = self.persistor || (respond_to(:save_to) && save_to.persistor)
+
+      # Check if we are on the store collection
+      if persistor.is_a?(Volt::Persistors::ModelStore)
+        # Get the root node
+        root = persistor.try(:root_model)
+
+        # Yield to the block passing in the root node
+        yield(root)
+      else
+        # raise an error about the method not being supported on this collection
+        fail "#{method_name} currently only works on the store collection (support for other collections coming soon)"
+      end
+    end
+  end
+end

data/lib/volt/models/buffer.rb

@@ -2,7 +2,7 @@ module Volt
   module Buffer
     def save!
       # Compute the erros once
-      errors = self.errors
+      errors = self.errors.to_h
 
       if errors.size == 0
         save_to = options[:save_to]
@@ -12,10 +12,13 @@ module Volt
             promise = save_to.append(attributes)
           else
             # We have a saved model
-            promise = save_to.assign_attributes(attributes)
+            promise = save_to.assign_attributes(attributes, true)
           end
 
           return promise.then do |new_model|
+            # The main model saved, so mark the buffer as not new
+            @new = false
+
             if new_model
               # Set the buffer's id to track the main model's id
               attributes[:_id] = new_model._id
@@ -46,25 +49,34 @@ module Volt
       Promise.new.reject(errors)
     end
 
+    def buffer?
+      options[:buffer]
+    end
+
+    def save_to
+      options[:save_to]
+    end
+
     # Returns a buffered version of the model
     def buffer
       model_path = options[: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
+      model_klass = self.class
 
-      new_options = options.merge(path: model_path, save_to: self).reject { |k, _| k.to_sym == :persistor }
+      new_options = options.merge(path: model_path, save_to: self, buffer: true).reject { |k, _| k.to_sym == :persistor }
       model       = model_klass.new({}, new_options, :loading)
 
-      if state == :loaded
+      if loaded?
         setup_buffer(model)
       else
         parent.then do
           setup_buffer(model)
+        end.fail do |err|
+          # TODO: right now this error gets ignored a lot, so lets log.
+          Volt.logger.error("error setting up buffer: #{err.inspect}")
+          Volt.logger.error(err.backtrace)
+
+          raise err
         end
       end
 

data/lib/volt/models/dirty.rb

@@ -0,0 +1,88 @@
+module Volt
+  # 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

data/lib/volt/models/errors.rb

@@ -0,0 +1,21 @@
+require 'volt/reactive/reactive_hash'
+
+module Volt
+  class Errors < ReactiveHash
+    def add(field, error)
+      field_errors = (self[field] ||= [])
+      field_errors << error unless field_errors.include?(error)
+    end
+
+    # Merge another set of errors in
+    def merge!(errors)
+      if errors
+        errors.each_pair do |field, messages|
+          messages.each do |message|
+            add(field, message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/volt/models/field_helpers.rb

@@ -11,7 +11,7 @@ module FieldHelpers
       end
 
       define_method(name) do
-        read_attribute(name)
+        get(name)
       end
 
       define_method(:"#{name}=") do |val|
@@ -25,7 +25,7 @@ module FieldHelpers
           end
         end
 
-        assign_attribute(name, val)
+        set(name, val)
       end
     end
   end

data/lib/volt/models/listener_tracker.rb

@@ -0,0 +1,17 @@
+module Volt
+  # 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