volt 0.8.27.beta3 → 0.8.27.beta4

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

@@ -17,12 +17,14 @@ module Volt
       # Listen for changes
       @computation = -> do
         begin
-          update(@context.instance_eval(&@getter))
+          @context.instance_eval(&@getter)
         rescue => e
           Volt.logger.error("AttributeBinding Error: #{e.inspect}")
-          update('')
+          ''
         end
-      end.watch!
+      end.watch_and_resolve! do |result|
+        update(result)
+      end
 
       @is_radio = element.is('[type=radio]')
       if @is_radio
@@ -122,9 +124,13 @@ module Volt
           element.off('change.attrbind', nil)
       end
 
+      if @computation
+        @computation.stop
+        @computation = nil
+      end
+
       @string_template_renderer.remove if @string_template_renderer
       @string_template_renderer_computation.stop if @string_template_renderer_computation
-      @computation.stop if @computation
 
       # Clear any references
       @target  = nil

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

@@ -9,12 +9,14 @@ module Volt
       # Listen for changes
       @computation = -> do
         begin
-          update(@context.instance_eval(&getter))
+          res = @context.instance_eval(&getter)
         rescue => e
           Volt.logger.error("ContentBinding Error: #{e.inspect}")
-          update('')
+          ''
         end
-      end.watch!
+      end.watch_and_resolve! do |result|
+        update(result)
+      end
     end
 
     def update(value)
@@ -29,8 +31,10 @@ module Volt
     end
 
     def remove
-      @computation.stop if @computation
-      @computation = nil
+      if @computation
+        @computation.stop
+        @computation = nil
+      end
 
       super
     end

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

@@ -24,7 +24,15 @@ module Volt
         @branches << [value, template_name]
       end
 
-      @computation = -> { update }.watch!
+      # The promise dependency can be invalidated when we need to rerun the update
+      # manually because a promise resolved.
+      @promise_dependency = Dependency.new
+
+      @computation = -> do
+        @promise_dependency.depend
+
+        update
+      end.watch!
     end
 
     def update
@@ -36,6 +44,22 @@ module Volt
         if value.is_a?(Proc)
           begin
             current_value = @context.instance_eval(&value)
+
+            if current_value.is_a?(Promise)
+              # If we got a promise, use its value if resolved.
+              if current_value.resolved?
+                current_value = current_value.value
+              else
+                # if its not, resolve it and try again.
+                # TODO: we maybe could cache this so we don't have to run a full update again
+                current_value.then do |val|
+                  # Run update again
+                  @promise_dependency.changed!
+                end
+
+                current_value = nil
+              end
+            end
           rescue => e
             Volt.logger.error("IfBinding:#{object_id} error: #{e.inspect}\n" + `value.toString()`)
             current_value = false
@@ -44,7 +68,6 @@ module Volt
           current_value = value
         end
 
-        # TODO: A bug in opal requires us to check == true
         if current_value && !current_value.nil? && !current_value.is_a?(Exception)
           # This branch is currently true
           true_template = template_name

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

@@ -3,11 +3,19 @@ require 'volt/page/template_renderer'
 require 'volt/page/bindings/template_binding/grouped_controllers'
 require 'volt/page/bindings/template_binding/view_lookup_for_path'
 
+
 module Volt
   class TemplateBinding < BaseBinding
-    def initialize(page, target, context, binding_name, binding_in_path, getter)
+
+    # @param [String]     binding_in_path is the path this binding was rendered from.  Used to
+    #                     lookup paths in ViewLookupForPath
+    # @param [String|nil] content_template_path is the path to the template for the content
+    #                     provided in the tag.
+    def initialize(page, target, context, binding_name, binding_in_path, getter, content_template_path=nil)
       super(page, target, context, binding_name)
 
+      @content_template_path = content_template_path
+
       # Setup the view lookup helper
       @view_lookup = Volt::ViewLookupForPath.new(page, binding_in_path)
 
@@ -47,6 +55,13 @@ module Volt
         else
           # Use the value passed in as the default arguments
           @arguments = section_or_arguments
+
+          # Include content_template_path in attrs
+          if @content_template_path
+            @arguments ||= {}
+            @arguments[:content_template_path] = @content_template_path
+            @arguments[:content_controller] = @context
+          end
         end
 
         # Sometimes we want multiple template bindings to share the same controller (usually
@@ -140,6 +155,9 @@ module Volt
     end
 
     def remove
+      @computation.stop
+      @computation = nil
+
       controller_send(:"before_#{@action}_remove") if @controller && @action
 
       clear_grouped_controller

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

@@ -0,0 +1,31 @@
+# The yield binding renders the content of a tag which passes in
+
+require 'volt/page/bindings/base_binding'
+require 'volt/page/template_renderer'
+
+module Volt
+  class YieldBinding < BaseBinding
+    def initialize(page, target, context, binding_name)
+      super(page, target, context, binding_name)
+
+      # Get the path to the template to yield
+      full_path = @context.attrs.content_template_path
+
+      # Grab the controller for the content
+      controller = @context.attrs.content_controller
+
+      @current_template = TemplateRenderer.new(@page, @target, controller, @binding_name, full_path)
+    end
+
+    def remove
+      if @current_template
+        # Remove the template if one has been rendered, when the template binding is
+        # removed.
+        @current_template.remove
+      end
+
+      super
+
+    end
+  end
+end

data/lib/volt/page/page.rb

@@ -1,5 +1,5 @@
+require 'opal'
 if RUBY_PLATFORM == 'opal'
-  require 'opal'
   require 'opal-jquery'
 end
 require 'volt/models'
@@ -10,6 +10,7 @@ require 'volt/page/bindings/content_binding'
 require 'volt/page/bindings/each_binding'
 require 'volt/page/bindings/if_binding'
 require 'volt/page/bindings/template_binding'
+require 'volt/page/bindings/yield_binding'
 require 'volt/page/bindings/component_binding'
 require 'volt/page/bindings/event_binding'
 require 'volt/page/template_renderer'
@@ -31,11 +32,9 @@ require 'volt/page/tasks'
 
 module Volt
   class Page
-    attr_reader :url, :params, :page, :templates, :routes, :events, :model_classes
+    attr_reader :url, :params, :page, :templates, :routes, :events
 
     def initialize
-      @model_classes = {}
-
       # Run the code to setup the page
       @page          = Model.new
 
@@ -139,14 +138,6 @@ module Volt
 
     attr_reader :events
 
-    def add_model(model_name)
-      model_name                 = model_name.camelize.to_sym
-      @model_classes[model_name] = Object.const_get(model_name)
-    rescue NameError => e
-      # Handle if the model is user (Volt's provided user model is scoped under Volt::)
-      raise unless model_name == :User
-    end
-
     def add_template(name, template, bindings)
       @templates ||= {}
 
@@ -159,7 +150,6 @@ module Volt
       unless @templates[name]
         @templates[name] = { 'html' => template, 'bindings' => bindings }
       end
-      # puts "Add Template: #{name}"
     end
 
     def add_routes(&block)
@@ -210,7 +200,7 @@ module Volt
         end
       end
     rescue => e
-      puts "Unable to restore: #{e.inspect}"
+      Volt.logger.error("Unable to restore: #{e.inspect}")
     end
   end
 
@@ -218,8 +208,13 @@ module Volt
     $page = Page.new
 
     # Call start once the page is loaded
-    Document.ready? do
+    # Document.ready? do
+    #   $page.start
+    # end
+
+    # For some reason Document.ready? (using opal-jquery) quit working.
+    `$(document).ready(function() {`
       $page.start
-    end
+    `});`
   end
 end

data/lib/volt/reactive/class_eventable.rb

@@ -0,0 +1,71 @@
+require 'volt/reactive/eventable'
+
+module Volt
+  # ClassEventable behaves like Eventable, except events can be bound with a class #on method.
+  # When triggered on an instance, the self in the block will be the instance it was triggered
+  # on.  This allows classes to easy setup listeners.
+  #
+  # Example:
+  #    class Post
+  #      on(:create) do
+  #        deny if owner?
+  #      end
+  #    end
+  module ClassEventable
+    module ClassMethods
+      # Eventable also provides a static version of on, which allows you to setup on
+      # events at the class level.  When the event triggers, self will be set to the
+      # instance it was triggered on.
+      def on(*events, &callback)
+        raise '.on requires an event' if events.size == 0
+
+        listener = Listener.new(self, events, callback)
+
+        self.__listeners__ ||= {}
+
+        events.each do |event|
+          listeners = self.__listeners__
+          listeners[event] ||= []
+          listeners[event] << listener
+        end
+      end
+
+      def remove_listener(event, listener)
+        listeners = self.__listeners__
+        if listeners
+          listeners[event].delete(listener)
+
+          if listeners[event].size == 0
+            # No registered listeners now on this event
+            listeners.delete(event)
+          end
+        end
+      end
+    end
+
+    module InstanceMethods
+      # Extend trigger! to also trigger class listeners
+      def trigger!(event, *args)
+        event = event.to_sym
+
+        super
+
+        if (klass_listeners = self.class.__listeners__)
+          klass_listeners[event].dup.each do |listener|
+            # Call each class listener with self set to the current instance
+            listener.instance_call(self, *args)
+          end
+        end
+      end
+    end
+
+    def self.included(base)
+      base.class_attribute :__listeners__
+
+      # Include the base eventable so the class can be triggered on
+      base.send :include, Volt::Eventable
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+  end
+end

data/lib/volt/reactive/computation.rb

@@ -11,12 +11,14 @@ module Volt
       @@current
     end
 
+    # @param [Proc] the code to run when the computation needs to compute
     def initialize(computation)
       @computation   = computation
       @invalidations = []
     end
 
-    # Runs the computation
+    # Runs the computation, called on initial run and
+    # when changed!
     def compute!
       @invalidated = false
 
@@ -24,7 +26,12 @@ module Volt
 
         @computing = true
         run_in do
-          @computation.call
+          if @computation.arity > 0
+            # Pass in the Computation so it can be canceled from within
+            @computation.call(self)
+          else
+            @computation.call
+          end
         end
         @computing = false
       end
@@ -49,7 +56,7 @@ module Volt
       unless @invalidated
         @invalidated = true
 
-        if !@stopped && !@computing
+        unless @stopped || @computing
           @@flush_queue << self
 
           # If we are in the browser, we queue a flush for the next tick
@@ -79,16 +86,24 @@ module Volt
     def run_in
       previous            = Computation.current
       Computation.current = self
-      yield
-      Computation.current = previous
+      begin
+        yield
+      ensure
+        Computation.current = previous
+      end
+
       self
     end
 
+    # Run a block without tracking any dependencies
     def self.run_without_tracking
       previous            = Computation.current
       Computation.current = nil
-      return_value        = yield
-      Computation.current = previous
+      begin
+        return_value        = yield
+      ensure
+        Computation.current = previous
+      end
       return_value
     end
 
@@ -118,9 +133,63 @@ end
 
 class Proc
   def watch!
-    Volt::Computation.new(self).run_in do
-      # run self
-      call
+    computation = Volt::Computation.new(self)
+
+    # Initial run
+    computation.compute!
+
+    # return the computation
+    computation
+  end
+
+  # Watches a proc until the value returned equals the passed
+  # in value.  When the value matches, the block is called.
+  #
+  # @param the value to match
+  # @return [Volt::Computation] the initial computation is returned.
+  def watch_until!(value, &block)
+    computation = -> do
+      # First fetch the value
+      result = self.call
+
+      if result == value
+        # Values match
+
+        # call the block
+        block.call
+
+        # stop the computation
+        computation.stop
+      end
+    end.watch!
+
+    computation
+  end
+
+  # Does an watch and if the result is a promise, resolves the promise.
+  # #watch_and_resolve! takes a block that will be passed the resolved results
+  # of the proc.
+  #
+  # Example:
+  #   -> { }
+  def watch_and_resolve!
+    unless block_given?
+      raise "watch_and_resolve! requires a block to call when the value is resolved or another value other than a promise is returned in the watch."
     end
+
+    computation = Proc.new do
+      result = self.call
+
+      if result.is_a?(Promise)
+        result.then do |final|
+          yield(final)
+        end
+      else
+        yield(result)
+      end
+    end.watch!
+
+    # Return the computation
+    computation
   end
 end

data/lib/volt/reactive/dependency.rb

@@ -3,12 +3,9 @@ require 'set'
 
 class Set
   def delete(o)
-    @hash.delete(o)
-  end
-
-  def delete?(o)
     if include?(o)
-      delete(o)
+      @hash.delete(o)
+      true
     else
       nil
     end
@@ -28,9 +25,21 @@ class Set
 end
 
 module Volt
+  # Dependencies are used to track the current computation so it can be re-run
+  # at a later point if this dependency changes.
+  #
+  # You can also pass an on_dep and on_stop_dep proc's to #initialize.
   class Dependency
-    def initialize
+    # Setup a new dependency.
+    #
+    # @param on_dep [Proc] a proc to be called the first time a computation depends
+    #   on this dependency.
+    # @param on_stop_dep [Proc] a proc to be called when no computations are depending
+    #   on this dependency anymore.
+    def initialize(on_dep=nil, on_stop_dep=nil)
       @dependencies = Set.new
+      @on_dep = on_dep
+      @on_stop_dep = on_stop_dep
     end
 
     def depend
@@ -42,10 +51,18 @@ module Volt
         added = @dependencies.add?(current)
 
         if added
-          # puts "Added #{self.inspect} to #{current.inspect}"
+          # The first time the dependency is depended on by this computation, we call on_dep
+          @on_dep.call if @on_dep && @dependencies.size == 1
+
           current.on_invalidate do
             # If @dependencies is nil, this Dependency has been removed
-            @dependencies.delete(current) if @dependencies
+            if @dependencies
+              # For set, .delete returns a boolean if it was deleted
+              deleted = @dependencies.delete(current)
+
+              # Call on stop dep if no more deps
+              @on_stop_dep.call if @on_stop_dep && deleted && @dependencies.size == 0
+            end
           end
         end
       end
@@ -60,6 +77,8 @@ module Volt
       @dependencies = Set.new
 
       deps.each(&:invalidate!)
+
+      @on_stop_dep.call if @on_stop_dep
     end
 
     # Called when a dependency is no longer needed

data/lib/volt/reactive/eventable.rb

@@ -2,9 +2,9 @@ module Volt
   # Listeners are returned from #on on a class with Eventable included.
   # Listeners can be stopped by calling #remove
   class Listener
-    def initialize(klass, event, callback)
+    def initialize(klass, events, callback)
       @klass    = klass
-      @event    = event
+      @events    = events
       @callback = callback
     end
 
@@ -12,10 +12,17 @@ module Volt
       @callback.call(*args) unless @removed
     end
 
+    # Call the callback with self set to instance
+    def instance_call(instance, *args)
+      instance.instance_exec(*args, &@callback)
+    end
+
     def remove
       @removed = true
 
-      @klass.remove_listener(@event, self)
+      @events.each do |event|
+        @klass.remove_listener(event, self)
+      end
 
       # Make things easier on the GC
       @klass    = nil
@@ -23,7 +30,7 @@ module Volt
     end
 
     def inspect
-      "<Listener:#{object_id} event=#{@event}>"
+      "<Listener:#{object_id} events=#{@events}>"
     end
   end
 
@@ -35,37 +42,44 @@ module Volt
     # the class, it will trigger any listener with the same event name.
     #
     # returns: a listener that has a #remove method to stop the listener.
-    def on(event, &callback)
-      event             = event.to_sym
-      listener          = Listener.new(self, event, callback)
+    def on(*events, &callback)
+      raise '.on requires an event' if events.size == 0
+
+      listener = Listener.new(self, events, callback)
+
       @listeners        ||= {}
-      @listeners[event] ||= []
-      @listeners[event] << listener
 
-      first_for_event = @listeners[event].size == 1
-      first           = first_for_event && @listeners.size == 1
+      events.each do |event|
+        event             = event.to_sym
+        @listeners[event] ||= []
+        @listeners[event] << listener
+
+        first_for_event = @listeners[event].size == 1
+        first           = first_for_event && @listeners.size == 1
 
-      # Let the included class know that an event was registered. (if it cares)
-      if self.respond_to?(:event_added)
-        # call event added passing the event, the scope, and a boolean if it
-        # is the first time this event has been added.
-        event_added(event, first, first_for_event)
+        # Let the included class know that an event was registered. (if it cares)
+        if self.respond_to?(:event_added)
+          # call event added passing the event, the scope, and a boolean if it
+          # is the first time this event has been added.
+          event_added(event, first, first_for_event)
+        end
       end
 
       listener
     end
 
+
     # Triggers event on the class the module was includeded.  Any .on listeners
     # will have their block called passing in *args.
     def trigger!(event, *args)
       event = event.to_sym
 
-      return unless @listeners && @listeners[event]
-
-      # TODO: We have to dup here because one trigger might remove another
-      @listeners[event].dup.each do |listener|
-        # Call the event on each listener
-        listener.call(*args)
+      if @listeners && @listeners[event]
+        # TODO: We have to dup here because one trigger might remove another
+        @listeners[event].dup.each do |listener|
+          # Call the event on each listener
+          listener.call(*args)
+        end
       end
     end
 

data/lib/volt/reactive/reactive_array.rb

@@ -91,7 +91,7 @@ module Volt
 
     # TODO: Handle a range
     def [](index)
-      # Handle a negative index
+      # Handle a negative index, depend on size
       index = size + index if index < 0
 
       # Get or create the dependency
@@ -125,7 +125,7 @@ module Volt
       # Handle a negative index
       index = size + index if index < 0
 
-      model      = @array.delete_at(index)
+      model = @array.delete_at(index)
 
       # Remove the dependency for that cell, and #remove it
       index_deps = @array_deps.delete_at(index)
@@ -244,7 +244,6 @@ module Volt
     def trigger_for_index!(index)
       # Trigger a change for the cell
       dep = @array_deps[index]
-
       dep.changed! if dep
     end
 

data/lib/volt/reactive/reactive_hash.rb

@@ -13,10 +13,13 @@ module Volt
       @hash == val
     end
 
+    def blank?
+      @hash.blank?
+    end
+
     # TODO: We should finish off this class for reactivity
     def method_missing(method_name, *args, &block)
       @all_deps.depend
-
       @hash.send(method_name, *args, &block)
     end
 
@@ -40,7 +43,9 @@ module Volt
     end
 
     def clear
-      @hash.each_pair do |key, _|
+      # Don't use .each_key so we get a clone here since we are
+      # deleting as we go.
+      @hash.keys.each do |key|
         delete(key)
       end
 
@@ -62,7 +67,7 @@ module Volt
 
     def inspect
       @all_deps.depend
-      "#<ReactiveHash #{@hash.inspect}>"
+      "#<#{self.class.name} #{@hash.inspect}>"
     end
   end
 end