volt 0.9.3.pre2 → 0.9.3.pre3

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

@@ -32,6 +32,35 @@ module Volt
     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
+
+
+
+
     module ClassMethods
       # Gets the class for a model at the specified path.
       def class_at_path(path)

data/lib/volt/models/permissions.rb

@@ -151,22 +151,33 @@ module Volt
         # Run the read permission check
         allow, deny = allow_and_deny_fields(:read)
 
+        result = nil
+
         if allow && allow != true && allow.size > 0
           # always keep id
           allow << :id
 
           # Only keep fields in the allow list
-          return @attributes.select { |key| allow.include?(key) }
+          result = @attributes.select { |key| allow.include?(key) }
         elsif deny == true
           # Only keep id
           # TODO: Should this be a full reject?
-          return @attributes.reject { |key| key != :id }
+          result = @attributes.reject { |key| key != :id }
         elsif deny && deny.size > 0
           # Reject any in the deny list
-          return @attributes.reject { |key| deny.include?(key) }
+          result = @attributes.reject { |key| deny.include?(key) }
         else
-          return @attributes
+          result = @attributes
         end
+
+        # Deeply filter any nested models
+        return result.map do |key, value|
+          if value.is_a?(Model)
+            value = value.filtered_attributes
+          end
+
+          [key, value]
+        end.to_h
       end
 
       private

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

@@ -167,6 +167,46 @@ module Volt
         Cursor.new([], opts)
       end
 
+      # Call a method on the model once the model is loaded.  Return a promise
+      # that will resolve the result of the method, or reject with any
+      # Exceptions.
+      def run_once_loaded(block)
+        promise = Promise.new
+
+        # call once the method is loaded.
+        model_loaded = proc do
+          begin
+            result = yield
+            promise.resolve(result)
+          rescue Exception => error
+            promise.reject(error)
+          end
+        end
+
+        # Run the block after resolve if a block is passed in
+        if block
+          promise2 = promise.then do |val|
+            block.call(val)
+          end
+        else
+          promise2 = promise
+        end
+
+        if @model.loaded_state == :loaded
+          model_loaded.call
+        else
+          proc do |comp|
+            if @model.loaded_state == :loaded
+              model_loaded.call
+
+              comp.stop
+            end
+          end.watch!
+        end
+
+        promise2
+      end
+
       # Returns a promise that is resolved/rejected when the query is complete.  Any
       # passed block will be passed to the promises then.  Then will be passed the model.
       def fetch(&block)

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

@@ -155,8 +155,7 @@ module Volt
 
       # Return the attributes that are only for this store, not any sub-associations.
       def self_attributes
-        # Don't store any sub-stores, those will do their own saving.
-        @model.attributes.reject { |k, v| v.is_a?(Model) || v.is_a?(ArrayModel) }
+        @model.self_attributes
       end
 
       def collection
@@ -170,6 +169,7 @@ module Volt
 
         # Do the actual writing of data to the database, only runs on the backend.
         def save_to_db!(values)
+          # puts "SAVE TO DB: #{values.inspect}"
           # Check to make sure the model has no validation errors.
           errors = @model.errors
           return errors if errors.present?

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

@@ -26,7 +26,9 @@ module Volt
         # When the initial data comes back, add it into the stores.
         @stores.dup.each do |store|
           # Clear if there are existing items
-          store.model.clear if store.model.size > 0
+          Volt.run_in_mode(:no_model_promises) do
+            store.model.clear if store.model.size > 0
+          end
 
           results.each do |index, data|
             store.add(index, data)

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

@@ -26,7 +26,8 @@ module Volt
         if method_name.plural?
           model = @model.new_array_model([], options)
         else
-          model                          = @model.new_model(nil, options)
+          options[:persistor] = @model.persistor
+          model= @model.new_model(nil, options)
 
           # TODO: Might not need to assign this
           @model.attributes ||= {}

data/lib/volt/models/root_models/root_models.rb

@@ -0,0 +1,31 @@
+# When you get the root of a collection (.store, .page, etc...), it gives you
+# back a unique class depending on the collection.  This allows you to add
+# things to the root easily.
+#
+# The name of the model will be {CollectionName}Root.  All root model classes
+# inherit from BaseRootModel, which provides methods to access the model's
+# from the root.  (store.items if you have an Item model for example)
+
+# Create a model that is above all of the root models.
+class BaseRootModel < Volt::Model
+end
+
+
+ROOT_MODEL_NAMES = [:Store, :Page, :Params, :Cookies, :LocalStore, :Flash]
+
+ROOT_MODEL_NAMES.each do |base_name|
+  Object.const_set("#{base_name}Root", Class.new(BaseRootModel))
+end
+
+module Volt
+  class RootModels
+    def self.add_model_class(klass)
+      method_name = klass.to_s.underscore.pluralize
+
+      # Create a getter for each model class off of root.
+      BaseRootModel.send(:define_method, method_name) do
+        get(method_name)
+      end
+    end
+  end
+end

data/lib/volt/models/root_models/store_root.rb

@@ -0,0 +1,36 @@
+# StoreRoot should already be setup when this class is already loaded.  It is a
+# Volt::Model that is loaded as the base class for the root of store.
+#
+# In order to support setting properties directly on store, we create a table
+# called "root_store_models", and create a single
+
+require 'volt/models/root_models/root_models'
+
+module Volt
+  module StoreRootHelpers
+    def model_for_root
+      root = get(:root_store_models).first_or_create
+
+      root
+    end
+
+
+    def get(attr_name, expand = false)
+      if attr_name.singular? && attr_name.to_sym != :id
+        model_for_root.get(attr_name, expand)
+      else
+        super
+      end
+    end
+
+    def set(attr_name, value, &block)
+      if attr_name.singular? && attr_name.to_sym != :id
+        model_for_root.set(attr_name, value, &block)
+      else
+        super
+      end
+    end
+  end
+end
+
+StoreRoot.send(:include, Volt::StoreRootHelpers)

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).fetch_first do |item|
+          return $page.store.get(model.path[-2]).where(query).first do |item|
             if item
               message = (args.is_a?(Hash) && args[:message]) || 'is already taken'
 

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

@@ -45,8 +45,13 @@ module Volt
           @removed_listener = @value.on('removed') { |position| item_removed(position) }
         end
 
-        templates_size = @templates.size
-        values_size    = values.size
+        templates_size = nil
+        values_size = nil
+
+        Volt.run_in_mode(:no_model_promises) do
+          templates_size = @templates.size
+          values_size    = values.size
+        end
 
         # Start over, re-create all nodes
         (templates_size - 1).downto(0) do |index|
@@ -59,65 +64,69 @@ module Volt
     end
 
     def item_removed(position)
-      # Remove dependency
-      @templates[position].context.locals[:_index_dependency].remove
-      @templates[position].context.locals["_#{@item_name}_dependency".to_sym].remove
+      Volt.run_in_mode(:no_model_promises) do
+        # Remove dependency
+        @templates[position].context.locals[:_index_dependency].remove
+        @templates[position].context.locals["_#{@item_name}_dependency".to_sym].remove
 
-      @templates[position].remove_anchors
-      @templates[position].remove
-      @templates.delete_at(position)
+        @templates[position].remove_anchors
+        @templates[position].remove
+        @templates.delete_at(position)
 
-      # Removed at the position, update context for every item after this position
-      update_indexes_after(position)
+        # Removed at the position, update context for every item after this position
+        update_indexes_after(position)
+      end
     end
 
     def item_added(position)
-      binding_name     = @@binding_number
-      @@binding_number += 1
-
-      if position >= @templates.size
-        # Setup new bindings in the spot we want to insert the item
-        dom_section.insert_anchor_before_end(binding_name)
-      else
-        # Insert the item before an existing item
-        dom_section.insert_anchor_before(binding_name, @templates[position].binding_name)
-      end
+      Volt.run_in_mode(:no_model_promises) do
+        binding_name     = @@binding_number
+        @@binding_number += 1
+
+        if position >= @templates.size
+          # Setup new bindings in the spot we want to insert the item
+          dom_section.insert_anchor_before_end(binding_name)
+        else
+          # Insert the item before an existing item
+          dom_section.insert_anchor_before(binding_name, @templates[position].binding_name)
+        end
 
-      # TODORW: :parent => @value may change
-      item_context                           = SubContext.new({ _index_value: position, parent: @value }, @context)
-      item_context.locals[@item_name.to_sym] = proc { @value[item_context.locals[:_index_value]] }
+        # TODORW: :parent => @value may change
+        item_context                           = SubContext.new({ _index_value: position, parent: @value }, @context)
+        item_context.locals[@item_name.to_sym] = proc { @value[item_context.locals[:_index_value]] }
 
-      position_dependency                    = Dependency.new
-      item_context.locals[:_index_dependency] = position_dependency
+        position_dependency                    = Dependency.new
+        item_context.locals[:_index_dependency] = position_dependency
 
-      # Get and set index
-      item_context.locals[:_index=]           = proc do |val|
-        position_dependency.changed!
-        item_context.locals[:_index_value] = val
-      end
+        # Get and set index
+        item_context.locals[:_index=]           = proc do |val|
+          position_dependency.changed!
+          item_context.locals[:_index_value] = val
+        end
 
-      # Get and set value
-      value_dependency                    = Dependency.new
-      item_context.locals["_#{@item_name}_dependency".to_sym] = value_dependency
+        # Get and set value
+        value_dependency                    = Dependency.new
+        item_context.locals["_#{@item_name}_dependency".to_sym] = value_dependency
 
-      item_context.locals["#{@item_name}=".to_sym] = proc do |val|
-        value_dependency.changed!
-        @value[item_context.locals[:_index_value]] = val
-      end
+        item_context.locals["#{@item_name}=".to_sym] = proc do |val|
+          value_dependency.changed!
+          @value[item_context.locals[:_index_value]] = val
+        end
 
-      # If the user provides an each_with_index, we can assign the lookup for the index
-      # variable here.
-      if @index_name
-        item_context.locals[@index_name.to_sym] = proc do
-          position_dependency.depend
-          item_context.locals[:_index_value]
+        # If the user provides an each_with_index, we can assign the lookup for the index
+        # variable here.
+        if @index_name
+          item_context.locals[@index_name.to_sym] = proc do
+            position_dependency.depend
+            item_context.locals[:_index_value]
+          end
         end
-      end
 
-      item_template = TemplateRenderer.new(@volt_app, @target, item_context, binding_name, @template_name)
-      @templates.insert(position, item_template)
+        item_template = TemplateRenderer.new(@volt_app, @target, item_context, binding_name, @template_name)
+        @templates.insert(position, item_template)
 
-      update_indexes_after(position)
+        update_indexes_after(position)
+      end
     end
 
     # When items are added or removed in the middle of the list, we need

data/lib/volt/page/page.rb

@@ -6,7 +6,7 @@ module Volt
     def initialize(volt_app)
       @volt_app = volt_app
       # Run the code to setup the page
-      @page          = Model.new
+      @page          = PageRoot.new
 
       @url         = URL.new
       @params      = @url.params
@@ -47,19 +47,19 @@ module Volt
     end
 
     def flash
-      @flash ||= Model.new({}, persistor: Persistors::Flash)
+      @flash ||= FlashRoot.new({}, persistor: Persistors::Flash)
     end
 
     def store
-      @store ||= Model.new({}, persistor: Persistors::StoreFactory.new(tasks))
+      @store ||= StoreRoot.new({}, persistor: Persistors::StoreFactory.new(tasks))
     end
 
     def local_store
-      @local_store ||= Model.new({}, persistor: Persistors::LocalStore)
+      @local_store ||= LocalStoreRoot.new({}, persistor: Persistors::LocalStore)
     end
 
     def cookies
-      @cookies ||= Model.new({}, persistor: Persistors::Cookies)
+      @cookies ||= CookiesRoot.new({}, persistor: Persistors::Cookies)
     end
 
     def tasks

data/lib/volt/reactive/reactive_array.rb

@@ -39,8 +39,10 @@ module Volt
       if block
         count = 0
 
-        size.times do |index|
-          count += 1 if block.call(self[index])
+        Volt.run_in_mode(:no_model_promises) do
+          size.times do |index|
+            count += 1 if block.call(self[index])
+          end
         end
 
         count
@@ -90,7 +92,7 @@ module Volt
     # TODO: Handle a range
     def [](index)
       # Handle a negative index, depend on size
-      index = size + index if index < 0
+      index = @array.size + index if index < 0
 
       # Get or create the dependency
       dep   = (@array_deps[index] ||= Dependency.new)
@@ -120,6 +122,7 @@ module Volt
     alias_method :length, :size
 
     def delete_at(index)
+      size = @array.size
       # Handle a negative index
       index = size + index if index < 0
 
@@ -183,8 +186,8 @@ module Volt
     def <<(value)
       result = (@array << value)
 
-      trigger_for_index!(size - 1)
-      trigger_added!(size - 1)
+      trigger_for_index!(@array.size - 1)
+      trigger_added!(@array.size - 1)
       trigger_size_change!
 
       result
@@ -192,7 +195,7 @@ module Volt
 
     def +(array)
       fail 'not implemented yet'
-      old_size = size
+      old_size = @array.size
 
       # TODO: += is funky here, might need to make a .plus! method
       result   = ReactiveArray.new(@array.dup + array)