volt 0.7.1 → 0.7.2

data/lib/volt/models/model_hash_behaviour.rb

@@ -27,12 +27,15 @@ module ModelHashBehaviour
     attributes.true?
   end
 
-  def delete(*args)
-    __clear_element(args[0])
-    attributes.delete(*args)
-    trigger_by_attribute!('changed', args[0])
+  def delete(name)
+    name = name.to_sym
+    __clear_element(name)
+    value = attributes.delete(name)
+    trigger_by_attribute!('changed', name)
 
-    @persistor.removed(args[0]) if @persistor
+    @persistor.removed(name) if @persistor
+
+    return value
   end
 
 

data/lib/volt/models/model_helpers.rb

@@ -12,13 +12,13 @@ module ModelHelpers
   end
 
   # Pass to the persisotr
-  def event_added(event, scope_provider, first)
-    @persistor.event_added(event, scope_provider, first) if @persistor
+  def event_added(event, scope_provider, first, first_for_event)
+    @persistor.event_added(event, scope_provider, first, first_for_event) if @persistor
   end
 
   # Pass to the persistor
-  def event_removed(event, no_more_events)
-    @persistor.event_removed(event, no_more_events) if @persistor
+  def event_removed(event, last, last_for_event)
+    @persistor.event_removed(event, last, last_for_event) if @persistor
   end
 
   # Gets the class for a model at the specified path.

data/lib/volt/models/model_state.rb

@@ -0,0 +1,22 @@
+# All models have a state that has to do with it being loaded, in process of
+# being loaded, or not yet loading.
+module ModelState
+
+  def state
+    if @persistor && @persistor.respond_to?(:state)
+      @persistor.state
+    else
+      @state || :loaded
+    end
+  end
+
+  def change_state_to(state)
+    @state = state
+  end
+
+  def loaded?
+    state == :loaded
+  end
+
+
+end

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

@@ -1,73 +1,70 @@
 require 'volt/models/persistors/store'
 require 'volt/models/persistors/query/query_listener_pool'
+require 'volt/models/persistors/store_state'
 
 module Persistors
   class ArrayStore < Store
+    include StoreState
+
     @@query_pool = QueryListenerPool.new
 
     attr_reader :model
-    attr_accessor :state
 
     def self.query_pool
       @@query_pool
     end
 
     def initialize(model, tasks=nil)
+      # puts "NEW ARRAY STORE FOR #{model.inspect}"
       super
 
-      @query = ReactiveValue.from_hash(@model.options[:query] || {})
+      query = @model.options[:query]
 
+      @query = ReactiveValue.from_hash(query || {})
     end
 
-    # Called when a collection loads
-    def loaded
-      change_state_to :not_loaded
-    end
-
-    def event_added(event, scope_provider, first)
-      puts "ADD EV: #{event} - #{first}"
+    def event_added(event, scope_provider, first, first_for_event)
       # First event, we load the data.
       load_data if first
     end
 
-    def event_removed(event, no_more_events)
+    def event_removed(event, last, last_for_event)
       # Remove listener where there are no more events on this model
-      if no_more_events && @query_listener && @model.listeners.size == 0
-        stop_listening
-      end
+      stop_listening if last
     end
 
     # Called when an event is removed and we no longer want to keep in
     # sync with the database.
     def stop_listening
-      @query_listener.remove_store(self)
-      @query_listener = nil
-
-      change_state_to :dirty
-    end
+      if @query_changed_listener
+        @query_changed_listener.remove
+        @query_changed_listener = nil
+      end
 
-    # Called from the QueryListener when the data is loaded
-    def change_state_to(new_state)
-      @state = new_state
+      if @query_listener
+        @query_listener.remove_store(self)
+        @query_listener = nil
+      end
 
-      # Trigger changed on the 'state' method
-      @model.trigger_for_methods!('changed', :state, :loaded?)
+      @state = :dirty
     end
 
     # Called the first time data is requested from this collection
     def load_data
       # Don't load data from any queried
       if @state == :not_loaded || @state == :dirty
-        puts "Load Data"
+        puts "Load Data at #{@model.path.inspect} - query: #{@query.inspect}"# on #{@model.inspect}"
         change_state_to :loading
 
         @query_changed_listener.remove if @query_changed_listener
         if @query.reactive?
+          # puts "SETUP REACTIVE QUERY LISTENER: #{@query.inspect}"
           # Query might change, change the query when it does
           @query_changed_listener = @query.on('changed') do
             stop_listening
 
-            load_data
+            # Don't load again if all of the listeners are gone
+            load_data if @model.has_listeners?
           end
         end
 
@@ -94,29 +91,50 @@ module Persistors
         end
       end
 
+      # puts "IN QUERY: #{query.inspect} - #{self.inspect}"
       @query_listener = @@query_pool.lookup(collection, query) do
         # Create if it does not exist
         QueryListener.new(@@query_pool, @tasks, collection, query)
       end
-      @query_listener.add_store(model.persistor)
+
+      @query_listener.add_store(self)
     end
 
     def find(query={})
-      model = ArrayModel.new([], @model.options.merge(:query => query))
+      model = Cursor.new([], @model.options.merge(:query => query))
 
       return ReactiveValue.new(model)
     end
 
+    # Fetch does a one time load of the data on an unloaded model and returns
+    # the result.
+    def fetch(&block)
+      # puts "FETCH: #{@state.inspect}"
+      if @state == :loaded
+        block.call(@model)
+      else
+        @fetch_callbacks ||= []
+        @fetch_callbacks << block
+
+        load_data
+      end
+    end
+
     # Called from backend
     def add(index, data)
       $loading_models = true
+      # puts "INSERT: #{data.inspect} into #{self.inspect}"
 
       new_options = @model.options.merge(path: @model.path + [:[]], parent: @model)
 
-      # Find the existing model, or create one
-      new_model = @@identity_map.find(data['_id']) { Model.new(data.symbolize_keys, new_options) }
+      # Don't add if the model is already in the ArrayModel
+      if !@model.cur.array.find {|v| v['_id'] == data['_id'] }
+        # Find the existing model, or create one
+        new_model = @@identity_map.find(data['_id']) { @model.new_model(data.symbolize_keys, new_options, :loaded) }
 
-      @model.insert(index, new_model)
+        # puts "ADD: #{new_model.attributes.inspect}"
+        @model.insert(index, new_model)
+      end
 
       $loading_models = false
     end
@@ -148,10 +166,6 @@ module Persistors
     # When a model is added to this collection, we call its "changed"
     # method.  This should trigger a save.
     def added(model, index)
-      unless defined?($loading_models) && $loading_models
-        model.persistor.changed
-      end
-
       if model.persistor
         # Tell the persistor it was added
         model.persistor.add_to_collection
@@ -164,7 +178,7 @@ module Persistors
         model.persistor.remove_from_collection
       end
 
-      if $loading_models
+      if defined?($loading_models) && $loading_models
         return
       else
         puts "delete #{channel_name} - #{model.attributes[:_id]}"

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

@@ -1,7 +1,7 @@
 module Persistors
   # Implements the base persistor functionality.
   class Base
-    def loaded
+    def loaded(initial_state=nil)
     end
 
     def changed(attribute_name)
@@ -15,10 +15,10 @@ module Persistors
       changed(attribute_name)
     end
 
-    def event_added(event, scope_provider, first)
+    def event_added(event, scope_provider, first, first_for_event)
     end
 
-    def event_removed(event, no_more_events)
+    def event_removed(event, last, last_for_event)
     end
   end
 end

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

@@ -1,8 +1,10 @@
 require 'volt/models/persistors/store'
-
+require 'volt/models/persistors/store_state'
 
 module Persistors
   class ModelStore < Store
+    include StoreState
+
     ID_CHARS = [('a'..'z'), ('A'..'Z'), ('0'..'9')].map {|v| v.to_a }.flatten
 
     attr_reader :model
@@ -51,7 +53,8 @@ module Persistors
 
     # Called when the model changes
     def changed(attribute_name=nil)
-      # puts "CHANGED: #{attribute_name.inspect} - #{@model.inspect}"
+      promise = Promise.new
+
       ensure_setup
 
       path_size = @model.path.size
@@ -60,13 +63,21 @@ module Persistors
           @model.attributes[:"#{@model.path[-4].singularize}_id"] = source._id
         end
 
-        puts "Save: #{collection} - #{self_attributes.inspect} - #{@model.path.inspect}"
-        @tasks.call('StoreTasks', 'save', collection, self_attributes)
+        @tasks.call('StoreTasks', 'save', collection, self_attributes) do |errors|
+          puts "SAVE GOT: #{errors.inspect}"
+          if errors.size == 0
+            promise.resolve
+          else
+            promise.reject(errors)
+          end
+        end
       end
+
+      return promise
     end
 
-    def event_added(event, scope_provider, first)
-      if first && event == :changed
+    def event_added(event, scope_provider, first, first_for_event)
+      if first_for_event && event == :changed
         ensure_setup
       end
     end

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

@@ -65,7 +65,6 @@ class QueryListener
     @stores.each do |store|
       store.add(index, data)
     end
-    puts "Added: #{index} - #{data.inspect}"
   end
 
   def removed(ids)
@@ -76,7 +75,6 @@ class QueryListener
 
   def changed(model_id, data)
     $loading_models = true
-    puts "From Backend: UPDATE: #{model_id} with #{data.inspect}"
     Persistors::ModelStore.changed(model_id, data)
     $loading_models = false
   end

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

@@ -32,10 +32,6 @@ module Persistors
       @model.attributes ||= {}
       @model.attributes[method_name] = model
 
-      # if model.is_a?(StoreArray)# && model.state == :not_loaded
-      #   model.load!
-      # end
-
       return model
     end
   end

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

@@ -0,0 +1,27 @@
+# StoreState provides method for a store to track its loading state.
+module StoreState
+
+  # Called when a collection loads
+  def loaded(initial_state=nil)
+    change_state_to(initial_state || :not_loaded)
+  end
+
+  def state
+    @state
+  end
+
+  # Called from the QueryListener when the data is loaded
+  def change_state_to(new_state)
+    @state = new_state
+
+    # Trigger changed on the 'state' method
+    @model.trigger_for_methods!('changed', :state, :loaded?)
+
+    if @state == :loaded && @fetch_callbacks
+      # Trigger each waiting fetch
+      @fetch_callbacks.compact.each {|fc| fc.call(@model) }
+      @fetch_callbacks = nil
+    end
+  end
+
+end

data/lib/volt/models/url.rb

@@ -60,7 +60,7 @@ class URL
       host_with_port = @host
     end
 
-    path, params = @router.url_for_params(@params)
+    path, params = @router.params_to_url(@params.deep_cur.to_h)
 
     new_url = "#{@scheme}://#{host_with_port}#{(path || @path).chomp('/')}"
 
@@ -127,7 +127,7 @@ class URL
       query_hash = self.query_hash
 
       # Get the params that are in the route
-      query_hash.merge!(@router.params_for_path(@path))
+      query_hash.merge!(@router.url_to_params(@path))
 
       # Loop through the .params we already have assigned.
       assign_from_old(@params, query_hash)

data/lib/volt/models/validations/length.rb

@@ -0,0 +1,13 @@
+module Validations
+  class Length
+    def self.validate(model, field_name, args)
+      errors = {}
+      value = model.send(field_name)
+      if !value || value.size < args
+        errors[field_name] = ["must be at least #{args} chars"]
+      end
+
+      return errors
+    end
+  end
+end

data/lib/volt/models/validations/validations.rb

@@ -0,0 +1,82 @@
+# require 'volt/models/validations/errors'
+require 'volt/models/validations/length'
+
+# Include in any class to get validation logic
+module Validations
+  module ClassMethods
+    def validate(field_name, options)
+      @validations ||= {}
+      @validations[field_name] = options
+    end
+
+    def validations
+      @validations
+    end
+  end
+
+  def self.included(base)
+    base.send :extend, ClassMethods
+  end
+
+  # Sometimes we want to skip checking a field until some event
+  # has happened (usually a field has been typed in or blurred)
+  def exclude_from_errors!(field_name)
+    @exclude_from_errors ||= {}
+    @exclude_from_errors[field_name] = true
+
+    @include_in_errors.delete(field_name) if @include_in_errors
+
+    trigger_for_methods!('changed', :errors, :marked_errors)
+  end
+
+  # Once a field is ready, we can use include_in_errors! to start
+  # showing its errors.
+  def mark_field!(field_name, trigger_changed=true)
+    @marked_fields ||= {}
+    @marked_fields[field_name] = true
+
+    if trigger_changed
+      trigger_for_methods!('changed', :errors, :marked_errors)
+    end
+  end
+
+  def marked_errors
+    errors(true)
+  end
+
+  def errors(marked_only=false)
+    errors = {}
+
+    validations = self.class.validations
+
+    if validations
+      # Merge into errors, combining any error arrays
+      merge = Proc.new do |new_errors|
+        errors.merge!(new_errors) do |key, new_val, old_val|
+          new_val + old_val
+        end
+      end
+
+      # Run through each validation
+      validations.each_pair do |field_name, options|
+        if marked_only
+          # When marked only, skip any validations on non-marked fields
+          next unless @marked_fields && @marked_fields[field_name]
+        end
+
+        options.each_pair do |validation, args|
+          # Call the specific validator, then merge the results back
+          # into one large errors hash.
+          case validation
+          when :length
+            merge.call(Length.validate(self, field_name, args))
+          end
+        end
+      end
+    end
+
+    # puts "ERROR: #{errors.inspect}"
+
+    return errors
+  end
+end

data/lib/volt/models.rb

@@ -1,10 +1,10 @@
 require 'volt/extra_core/extra_core'
 require 'volt/reactive/reactive_value'
 require 'volt/models/model'
+require 'volt/models/cursor'
 require 'volt/models/persistors/store_factory'
 require 'volt/models/persistors/array_store'
 require 'volt/models/persistors/model_store'
 require 'volt/models/persistors/params'
 require 'volt/models/persistors/flash'
 require 'volt/models/persistors/local_store'
-

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

@@ -20,14 +20,16 @@ class AttributeBinding < BaseBinding
     # Run the initial update (render)
     update
 
-    @update_listener = @value.on('changed') { update }
-
-    # Bind so when this value updates, we update
-    case @attribute_name
-    when 'value'
-      element.on('input.attrbind') { changed }
-    when 'checked'
-      element.on('change.attrbind') {|event| changed(event) }
+    if @value.reactive?
+      @update_listener = @value.on('changed') { update }
+
+      # Bind so when this value updates, we update
+      case @attribute_name
+      when 'value'
+        element.on('input.attrbind') { changed }
+      when 'checked'
+        element.on('change.attrbind') {|event| changed(event) }
+      end
     end
   end
 
@@ -40,7 +42,9 @@ class AttributeBinding < BaseBinding
       current_value = element.is(':checked')
     end
 
+    # puts "ASSIGN #{current_value}"
     @value.cur = current_value
+    # puts "ASSIGNED"
   end
 
   def element
@@ -48,11 +52,10 @@ class AttributeBinding < BaseBinding
   end
 
   def update
-    if @attribute_target
-      value = @attribute_target.to_html
-    else
-      value = @value.cur
-    end
+    # puts "UPDATE GET VAL"
+    value = @value.cur
+    # puts "UPDATE GOT"
+    # puts "UPDATE1 to #{value.inspect}"
 
     if @attribute_name == 'checked'
       update_checked
@@ -91,6 +94,7 @@ class AttributeBinding < BaseBinding
   end
 
   def remove
+    # puts "REMOVE #{self.inspect}"
     # Unbind events, leave the element there since attribute bindings
     # aren't responsible for it being there.
     case @attribute_name
@@ -100,6 +104,12 @@ class AttributeBinding < BaseBinding
       element.off('change.attrbind', nil)
     end
 
+    # Value is a reactive template, remove it
+    if @value && @value.reactive?
+      @value.remove
+    end
+
+
     if @update_listener
       @update_listener.remove
       @update_listener = nil
@@ -108,7 +118,12 @@ class AttributeBinding < BaseBinding
     # Clear any references
     @target = nil
     @context = nil
-    @section = nil
+    @getter = nil
+    @value = nil
+  end
+
+  def remove_anchors
+    raise "attribute bindings do not have anchors, can not remove them"
   end
 
 

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

@@ -26,7 +26,7 @@ class BaseBinding
   end
 
   def remove
-    section.remove
+    section.remove if @section
 
     # Clear any references
     @target = nil
@@ -43,7 +43,7 @@ class BaseBinding
       # Run right away
       update
     else
-
+      @page.draw_cycle.queue(self)
     end
   end
 

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

@@ -4,30 +4,34 @@ require 'volt/page/bindings/template_binding'
 # and do not pass their context through
 class ComponentBinding < TemplateBinding
   # The context for a component binding can be either the controller, or the
-  # component arguments (@model), with the $page as the context.  This gives
+  # component arguments (@arguments), with the $page as the context.  This gives
   # components access to the page collections.
-  def render_template(full_path, controller_name)
-    # TODO: at the moment a :body section and a :title will both initialize different
-    # controllers.  Maybe we should have a way to tie them together?
-    controller_class = get_controller(controller_name)
-    model_with_parent = {parent: @context}.merge(@model || {})
-
-    if controller_class
-      # The user provided a controller, pass in the model as an argument (in a
-      # sub-context)
-      args = []
-      args << SubContext.new(model_with_parent) if @model
-
-      current_context = controller_class.new(*args)
-      @controller = current_context
-    else
-      # There is not a controller
-      current_context = SubContext.new(model_with_parent, $page)
-      @controller = nil
-    end
-
-    @current_template = TemplateRenderer.new(@page, @target, current_context, @binding_name, full_path)
-
-    call_ready
-  end
+  # def render_template(full_path, controller_path)
+  #   # TODO: at the moment a :body section and a :title will both initialize different
+  #   # controllers.  Maybe we should have a way to tie them together?
+  #   controller_class, action = get_controller(controller_path)
+  #
+  #   model_with_parent = {parent: @context}.merge(@arguments || {})
+  #
+  #   if controller_class
+  #     # The user provided a controller, pass in the model as an argument (in a
+  #     # sub-context)
+  #     args = []
+  #     args << SubContext.new(model_with_parent) if @arguments
+  #
+  #     current_context = controller_class.new(*args)
+  #     @controller = current_context
+  #
+  #     # Trigger the action
+  #     @controller.send(action) if @controller.respond_to?(action)
+  #   else
+  #     # There is not a controller
+  #     current_context = SubContext.new(model_with_parent, @page)
+  #     @controller = nil
+  #   end
+  #
+  #   @current_template = TemplateRenderer.new(@page, @target, current_context, @binding_name, full_path)
+  #
+  #   call_ready
+  # end
 end

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

@@ -21,6 +21,7 @@ class ContentBinding < BaseBinding
 
     # Exception values display the exception as a string
     value = value.to_s
+    # puts "UPDATE C: #{value.inspect} on #{self.inspect}"
 
     # Update the html in this section
     # TODO: Move the formatter into another class.