volt 0.9.0.pre4 → 0.9.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4d4f11c399ddcd63de7bc157707e0b1e5a91561
-  data.tar.gz: 773ade706e860021c11bf7d22c78e868fa51d139
+  metadata.gz: c6b166ab0b3c9e33c493d7c65d65d3c5db8f9cdb
+  data.tar.gz: 406513b0bc558b964c2207cf6b9ee4f66796d65e
 SHA512:
-  metadata.gz: 0542352171aa44247b3471c8e3ea3838e6d2127f896c56312b127936d523840c6d6e76c7ad16126e46844322004ef119bc1949696e83563b9754db8bc014cbf0
-  data.tar.gz: fcb365747674befac85bf8a8b08bf64addb800fb193500e822a8f4cb7cad4ea20ee51f67688d4aedcb47bc89b189867b9c18d39e65ac79c1f2a680ffb457845a
+  metadata.gz: 0350b5ca4ba46fc30c183be534f5e0ba4b0a4ba1af4cfedf4599a354d91a2f72865aaba9d639fe821001740874c9cc6b73d2dff095a673d3b128d22ca3bcd75c
+  data.tar.gz: 6ba8bd6674ea7057d27ab6259b203c8397c023b43c39eaf0d66573e36c44d56c1dc606e357a1d921016b3271101b78d7696d417896c697f3a2ed354c74e38446

data/CHANGELOG.md

@@ -22,9 +22,12 @@
 - ```store``` is now available inside of specs.  If it is accessed in a spec, the database will be cleaned after the spec.
 - ```the_page``` is a shortcut to the page collection inside of specs.  (Unfortunately, ```page``` is used by capybara, so for now we're using ```the_page```, we'll find a better solution in the future.)
 - Add filtering to logging on password, and option to configure filtered args.  Also, improve the way errors are displayed.
+- You can now call raw in a content binding to render the raw html on the page.  Use carefully, this can open you up to xss attacks.  We reccomend never showing html from the user directly.
 
 ### Changed
 - template bindings have been renamed to view.  ```{{ view "path/for/view" }}``` instead of ```{{ template "path/for/view" }}```
+- view bindings (formerly template) wait until the template's #loaded? method returns true (by .watch! ing it for changes)
+- #loaded? on controllers now returns false if the model is set to a Promise, until the promise is resolved.
 - the {action}_remove method had been changed to before_{action}_remove and after_{action}_remove to provide more hooks and a clearer understanding of when it is happening.
 - the following were renamed to follow gem naming conventions:
   - volt-user-templates (now volt-user_templates)
@@ -46,6 +49,7 @@
 - Volt::TaskHandler is now Volt::Task
 - Move testing gems to the generated Gemfile for projects
 - ```if ENV['BROWSER']``` is no longer required around integration tests.  We now use rspec filtering on ```type: :feature``` if you aren't running with ENV['BROWSER']
+- ```go``` has been renamed to ```redirect_to``` to keep things consistent between ruby frameworks. (And to allow for go to be used elsewhere)
 
 ### Removed
 - .false?, .true?, .or, and .and were removed since NilModels were removed.  This means you get back a real nil value when accessing an undefined model attribute.

data/VERSION

@@ -1 +1 @@
-0.9.0.pre4
+0.9.0.pre5

data/app/volt/tasks/live_query/live_query_pool.rb

@@ -19,9 +19,7 @@ class LiveQueryPool < Volt::GenericPool
 
   def updated_collection(collection, skip_channel)
     # collection = collection.to_sym
-    # puts "RUN UPDATE FOR #{collection.inspect} - #{@pool.inspect}"
     lookup_all(collection).each do |live_query|
-      # puts "UPDATE COLLECTION: #{collection} - #{live_query.inspect}"
       live_query.run(skip_channel)
     end
   end

data/lib/volt/controllers/actions.rb

@@ -0,0 +1,101 @@
+# The Actions module adds helpers for setting up and using
+# actions on a class.  You can setup helpers for an action with
+#
+#   setup_action_helpers_in_class(:before, :after)
+#
+# The above will setup before_action and after_action methods on
+# the class.  Typically setup_action_helpers_in_class will be run
+# in a base class.
+#
+#   before_action :require_login
+module Volt
+  module Actions
+    # StopChainException inherits from Exception directly so it will not be handled by a
+    # default rescue.
+    class StopChainException < Exception ; end
+
+    module ClassMethods
+      # Takes a list of action groups (as symbols).  An action group is typically used for before/after, but
+      # can be used anytime you have multiple sets of actions.  The method will create an {x}_action method for each
+      # group passed in.
+      def setup_action_helpers_in_class(*groups)
+        groups.each do |group|
+          # Setup a class attribute to track the
+          callbacks_var_name = :"#{group}_action_callbacks"
+          class_attribute(callbacks_var_name)
+
+          # Create the method on the class
+          define_singleton_method(:"#{group}_action") do |*args, &block|
+            # Add the block in place of the symbol
+            args.unshift(block) if block
+
+            raise "No callback symbol or block provided" unless args[0]
+
+            callbacks = send(callbacks_var_name)
+
+            unless callbacks
+              callbacks = []
+              send(:"#{callbacks_var_name}=", callbacks)
+            end
+
+            if args.last.is_a?(Hash)
+              options = args.pop
+            else
+              options = nil
+            end
+
+            args.each do |callback|
+              callbacks << [callback, options]
+            end
+          end
+        end
+      end
+    end
+
+    # To run the actions on a class, call #run_actions passing in the group
+    # and the action being called on.  If the callback chain was stopped with
+    # #stop_chain, it will return true, otherwise false.
+    def run_actions(group, action)
+      callbacks = self.class.send(:"#{group}_action_callbacks")
+
+      filtered_callbacks = filter_actions_by_only_exclude(callbacks || [], action)
+
+      begin
+        filtered_callbacks.each do |callback|
+          instance_eval(&callback)
+        end
+
+        return false
+      rescue StopChainException => e
+        return true
+      end
+    end
+
+    # The stop chain method can be called inside of a callback and it will
+    # raise an exception under the hood which will stop the chain and evaluation
+    # from where stop_chain is called.
+    def stop_chain
+      raise StopChainException
+    end
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    private
+    # TODO: currently we filter during the call, we could maybe improve performance
+    # here by storing by action and having an all category as well.
+    def filter_actions_by_only_exclude(callbacks, action)
+      callbacks.select do |callback, options|
+        if options
+          # If there is an only, make sure the action is in the list.
+          options[:only].include?(action.to_sym)
+        else
+          # If no only, include it
+          true
+        end
+      end.map {|v| v[0] }
+    end
+
+  end
+end

data/lib/volt/controllers/model_controller.rb

@@ -1,15 +1,21 @@
 require 'volt/reactive/reactive_accessors'
+require 'volt/controllers/actions'
 
 module Volt
   class ModelController
     include ReactiveAccessors
+    include Actions
 
     reactive_accessor :current_model
+    reactive_accessor :last_promise
 
     # The section is assigned a reference to a "DomSection" which has
     # the dom for the controllers view.
     attr_accessor :section
 
+    # Setup before_action and after_action
+    setup_action_helpers_in_class(:before, :after)
+
     # Container returns the node that is parent to all nodes in the section.
     def container
       section.container_node
@@ -40,11 +46,11 @@ module Volt
     def model=(val)
       if val.is_a?(Promise)
         # Resolve the promise before setting
-        @last_promise = val
+        self.last_promise = val
 
         val.then do |result|
           # Only assign if nothing else has been assigned since we started the resolve
-          self.model = result if @last_promise == val
+          self.model = result if self.last_promise == val
         end.fail do |err|
           Volt.logger.error("Unable to resolve promise assigned to model on #{inspect}")
         end
@@ -53,7 +59,7 @@ module Volt
       end
 
       # Clear
-      @last_promise = nil
+      self.last_promise = nil
 
       # Start with a nil reactive value.
       self.current_model ||= Model.new
@@ -106,8 +112,14 @@ module Volt
       end
     end
 
-    # Change the url params, similar to redirecting to a new url
     def go(url)
+      Volt.logger.warn('Deprecation warning: `go` has been renamed to `redirect_to` for consistency with other frameworks.')
+
+      redirect_to(url)
+    end
+
+    # Change the url
+    def redirect_to(url)
       # We might be in the rendering loop, so wait until the next tick before
       # we change the url
       Timers.next_tick do
@@ -163,8 +175,36 @@ module Volt
       $page.url.url_with(params)
     end
 
+    # loaded? is a quick way to see if the model for the controller is loaded
+    # yet.  If the model is there, it asks the model if its loaded.  If the model
+    # was set to a promise, it waits for the promise to resolve.
     def loaded?
-      self.model.respond_to?(:loaded?) && self.model.loaded?
+      if model.respond_to?(:loaded?)
+        # There is a model and it is loaded
+        return model.loaded?
+      elsif last_promise || model.is_a?(Promise)
+        # The model is a promise or is resolving
+        return false
+      else
+        # Otherwise, its loaded
+        return true
+      end
+    end
+
+    def require_login(message="You must login to access this area.")
+      unless Volt.current_user_id
+        flash._notices << message
+        go '/login'
+
+        stop_chain
+      end
+    end
+
+    # Raw marks a string as html safe, so bindings can be rendered as html.
+    # With great power comes great responsibility.
+    def raw(str)
+      str = str.to_s unless str.is_a?(String)
+      str.html_safe
     end
 
     # Check if this controller responds_to method, or the model

data/lib/volt/models/buffer.rb

@@ -30,6 +30,9 @@ module Volt
             @new = false
 
             if new_model
+              # Mark the model as loaded
+              new_model.change_state_to(:loaded_state, :loaded)
+
               # Set the buffer's id to track the main model's id
               attributes[:_id] = new_model._id
               options[:save_to]     = new_model

data/lib/volt/models/model.rb

@@ -80,7 +80,7 @@ module Volt
       if @persistor
         @persistor.loaded(initial_state)
       else
-        change_state_to(:loaded_state, :loaded, false)
+        change_state_to(:loaded_state, initial_state || :loaded, false)
       end
 
       # Trigger the new event, pass in :new
@@ -293,8 +293,8 @@ module Volt
       end
     end
 
-    def new_model(attributes, options)
-      Volt::Model.class_at_path(options[:path]).new(attributes, options)
+    def new_model(*args)
+      Volt::Model.class_at_path(options[:path]).new(*args)
     end
 
     def new_array_model(attributes, options)

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

@@ -3,6 +3,7 @@ module Volt
     # Implements the base persistor functionality.
     class Base
       def loaded(initial_state = nil)
+        @model.change_state_to(:loaded_state, initial_state || :loaded)
       end
 
       def changed(attribute_name)

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

@@ -22,6 +22,14 @@ module Volt
         @in_identity_map = false
       end
 
+      def loaded(initial_state = nil)
+        if model.path == []
+          initial_state = :loaded
+        end
+
+        model.change_state_to(:loaded_state, initial_state)
+      end
+
       def add_to_collection
         @in_collection = true
         ensure_setup

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

@@ -1,7 +1,11 @@
 require 'volt/page/bindings/base_binding'
+require 'volt/page/bindings/html_safe/string_extension'
 
 module Volt
   class ContentBinding < BaseBinding
+    HTML_ESCAPE_REGEXP = /[&"'><\n]/
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;', "\n" => "<br />\n" }
+
     def initialize(page, target, context, binding_name, getter)
       # puts "New Content Binding: #{self.inspect}"
       super(page, target, context, binding_name)
@@ -20,14 +24,32 @@ module Volt
     end
 
     def update(value)
-      value            = value || ''
+      value = (value || '').to_s unless value.is_a?(String)
+      html_safe = value.html_safe?
 
       # Exception values display the exception as a string
-      value            = value.to_s
+      value = value.to_s
 
       # Update the html in this section
       # TODO: Move the formatter into another class.
-      dom_section.text = value.gsub("\n", "<br />\n")
+
+      # The html safe check lets us know that if string can be rendered
+      # directly as html
+      unless html_safe
+        # Escape any < and >, but convert newlines to br's, and fix quotes and
+        value = html_escape(value)
+      end
+
+      # Assign the content
+      dom_section.html = value
+      # dom_section.text = value
+    end
+
+    def html_escape(str)
+      # https://github.com/opal/opal/issues/798
+      str.gsub(HTML_ESCAPE_REGEXP) do |char|
+        HTML_ESCAPE[char]
+      end
     end
 
     def remove

data/lib/volt/page/bindings/html_safe/string_extension.rb

@@ -0,0 +1,13 @@
+class String
+  def html_safe
+    # Convert to a real string (opal uses native strings normally, so wrap so we can
+    # use instance variables)
+    str = String.new(self)
+    str.instance_variable_set('@html_safe', true)
+    str
+  end
+
+  def html_safe?
+    @html_safe
+  end
+end

data/lib/volt/page/bindings/view_binding/controller_handler.rb

@@ -0,0 +1,44 @@
+module Volt
+  class ControllerHandler
+    attr_reader :controller, :action
+
+    def initialize(controller, action)
+      @controller = controller
+      @action = action.to_sym
+    end
+
+    def call_action(stage_prefix=nil, stage_suffix=nil)
+      return unless @action
+
+      has_stage = stage_prefix || stage_suffix
+
+      if has_stage
+        method_name = @action
+        method_name = "#{stage_prefix}_#{method_name}" if stage_prefix
+        method_name = "#{method_name}_#{stage_suffix}" if stage_suffix
+
+        method_name = method_name.to_sym
+      else
+        method_name = @action
+      end
+
+      # If no stage, then we are calling the main action method,
+      # so we should call the before/after actions
+      unless has_stage
+        if @controller.run_actions(:before, @action)
+          # stop_chain was called
+          return true
+        end
+      end
+
+      if @controller.respond_to?(method_name)
+        @controller.send(method_name)
+      end
+
+      @controller.run_actions(:after, @action) unless has_stage
+
+      # before_action chain was not stopped
+      return false
+    end
+  end
+end

data/lib/volt/page/bindings/view_binding/grouped_controllers.rb

@@ -1,39 +1,27 @@
 # Some template bindings share the controller with other template bindings based
-# on a name.  This class keeps track of the number of templates using this controller
-# and clears it once no one else is using it.  Use #get or #inc to add to the count.
-# #clear removes 1 from the count.  When the count is 0, delete the controller.
+# on a name.  This class creates a cache based on the group_controller name and the
+# controller class.
 module Volt
   class GroupedControllers
-    @@controllers = {}
-
     def initialize(name)
       @name = name
+      @@pool ||= GenericCountingPool.new
     end
 
-    def get
-      (controller = self.controller) && controller[0]
-    end
-
-    def set(controller)
-      @@controllers[@name] = [controller, 1]
+    def lookup_or_create(controller, &block)
+      @@pool.find(@name, controller, &block)
     end
 
-    def inc
-      controller[1] += 1
+    def remove(controller)
+      @@pool.remove(@name, controller)
     end
 
     def clear
-      controller    = self.controller
-      controller[1] -= 1
-      if controller[1] == 0
-        @@controllers.delete(@name)
-      end
+      @@pool.clear
     end
 
-    private
-
-    def controller
-      @@controllers[@name]
+    def inspect
+      "<GroupedController @name:#{@name.inspect} #{@@pool.inspect}>"
     end
   end
 end

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

@@ -2,6 +2,7 @@ require 'volt/page/bindings/base_binding'
 require 'volt/page/template_renderer'
 require 'volt/page/bindings/view_binding/grouped_controllers'
 require 'volt/page/bindings/view_binding/view_lookup_for_path'
+require 'volt/page/bindings/view_binding/controller_handler'
 
 
 module Volt
@@ -31,15 +32,9 @@ module Volt
       end.watch!
     end
 
+    # update is called when the path string changes.
     def update(path, section_or_arguments = nil, options = {})
       Computation.run_without_tracking do
-        # Remove existing template and call _removed
-        controller_send(:"#{@action}_removed") if @action && @controller
-        if @current_template
-          @current_template.remove
-          @current_template = nil
-        end
-
         @options = options
 
         # A blank path needs to load a missing template, otherwise it tries to load
@@ -67,15 +62,57 @@ module Volt
         # Sometimes we want multiple template bindings to share the same controller (usually
         # when displaying a :Title and a :Body), this instance tracks those.
         if @options && (controller_group = @options[:controller_group])
+          # Setup the grouped controller for the first time.
           @grouped_controller = GroupedControllers.new(controller_group)
-        else
-          clear_grouped_controller
         end
 
+        # If a controller is already starting, but not yet started, then remove it.
+        remove_starting_controller
+
         full_path, controller_path = @view_lookup.path_for_template(path, section)
-        render_template(full_path, controller_path)
 
-        queue_clear_grouped_controller
+        unless full_path
+          # if we don't have a full path, then we have a missing template
+          render_next_template(full_path, path)
+          return
+        end
+
+        @starting_controller_handler, generated_new, chain_stopped = create_controller_handler(full_path, controller_path)
+
+        # Check if chain was stopped when the action ran
+        if chain_stopped
+          # An action stopped the chain.  When this happens, we stop running here.
+          remove_starting_controller
+        else
+          # None of the actions stopped the chain
+
+          # Wait until the controller is loaded before we actually render.
+          @waiting_for_load = -> { @starting_controller_handler.controller.loaded? }.watch_until!(true) do
+            render_next_template(full_path, path)
+          end
+
+          queue_clear_grouped_controller
+        end
+      end
+    end
+
+    # Called when the next template is ready to render
+    def render_next_template(full_path, path)
+      begin
+        remove_current_controller_and_template
+
+        # Switch the current template
+        @current_controller_handler = @starting_controller_handler
+        @starting_controller_handler = nil
+
+        # Also track the current controller directly
+        @controller = @current_controller_handler.controller if full_path
+
+        @waiting_for_load = nil
+        render_template(full_path || path)
+      rescue => e
+        Volt.logger.error("Error during render of template at #{path}: #{e.inspect}")
+        Volt.logger.error(e.backtrace)
       end
     end
 
@@ -101,41 +138,90 @@ module Volt
       end
     end
 
-    # The context for templates can be either a controller, or the original context.
-    def render_template(full_path, controller_path)
-      # If arguments is nil, then an blank SubContext will be created
-      args = [SubContext.new(@arguments, nil, true)]
+    def remove_current_controller_and_template
+      # Remove existing controller and template and call _removed
+      if @current_controller_handler
+        @current_controller_handler.call_action('before', 'remove')
+      end
+
+      if @current_template
+        @current_template.remove
+        @current_template = nil
+      end
+
+      if @current_controller_handler
+        @current_controller_handler.call_action('after', 'remove')
+      end
+
+      if @grouped_controller && @current_controller_handler
+        # Remove a reference for the controller in the group.
+        @grouped_controller.remove(@current_controller_handler.controller.class)
+      end
 
       @controller = nil
+      @current_controller_handler = nil
+    end
 
-      # Fetch grouped controllers if we're grouping
-      @controller = @grouped_controller.get if @grouped_controller
+    def remove_starting_controller
+      # Clear any previously running wait for loads.  This is for when the path changes
+      # before the view actually renders.
+      if @waiting_for_load
+        @waiting_for_load.stop
+      end
 
-      # The action to be called and rendered
-      @action     = nil
+      if @starting_controller_handler
+        # Only call the after_..._removed because the dom never loaded.
+        @starting_controller_handler.call_action('after', 'removed')
+        @starting_controller_handler = nil
+      end
+    end
 
-      if @controller
-        # Track that we're using the group controller
-        @grouped_controller.inc if @grouped_controller
+    # Create controller handler loads up a controller inside of the controller handler for the paths
+    def create_controller_handler(full_path, controller_path)
+      # If arguments is nil, then an blank SubContext will be created
+      args = [SubContext.new(@arguments, nil, true)]
+
+      # get the controller class and action
+      controller_class, action = get_controller(controller_path)
+      controller_class ||= ModelController
+
+      generated_new = false
+      new_controller = Proc.new do
+        # Mark that we needed to generate a new controller instance (not reused
+        # from the group)
+        generated_new = true
+        # Setup the controller
+        controller_class.new(*args)
+      end
+
+      # Fetch grouped controllers if we're grouping
+      if @grouped_controller
+        # Find the controller in the group, or create it
+        controller = @grouped_controller.lookup_or_create(controller_class, &new_controller)
       else
-        # Otherwise, make a new controller
-        controller_class, @action = get_controller(controller_path)
+        # Just create the controller
+        controller = new_controller.call
+      end
 
-        if controller_class
-          # Setup the controller
-          @controller = controller_class.new(*args)
-        else
-          @controller = ModelController.new(*args)
-        end
+      handler = ControllerHandler.new(controller, action)
 
-        # Trigger the action
-        controller_send(@action) if @action
+      if generated_new
+        # Call the action
+        stopped = handler.call_action
 
-        # Track the grouped controller
-        @grouped_controller.set(@controller) if @grouped_controller
+        if stopped
+          controller.instance_variable_set('@chain_stopped', true)
+        end
+      else
+        stopped = controller.instance_variable_get('@chain_stopped')
       end
 
-      @current_template = TemplateRenderer.new(@page, @target, @controller, @binding_name, full_path)
+      return handler, generated_new, stopped
+    end
+
+    # The context for templates can be either a controller, or the original context.
+    def render_template(full_path, path)
+      @current_template = TemplateRenderer.new(@page, @target, @controller, @binding_name, full_path, path)
 
       call_ready
     end
@@ -146,49 +232,32 @@ module Volt
         # the dom if needed
         # Only assign sections for action's, so we don't get AttributeSections bound
         # also.
-        if @action && @controller.respond_to?(:section=)
+        if @controller.respond_to?(:section=)
           @controller.section = @current_template.dom_section
         end
 
-        controller_send(:"#{@action}_ready") if @action
+        # Call the ready callback on the controller
+        @current_controller_handler.call_action(nil, 'ready')
       end
     end
 
+    # Called when the binding is removed from the page
     def remove
+      # Cleanup any starting controller
+      remove_starting_controller
+
       @computation.stop
       @computation = nil
 
-      controller_send(:"before_#{@action}_remove") if @controller && @action
-
-      clear_grouped_controller
-
-      if @current_template
-        # Remove the template if one has been rendered, when the template binding is
-        # removed.
-        @current_template.remove
-      end
+      remove_current_controller_and_template
 
       super
-
-      if @controller
-        controller_send(:"after_#{@action}_remove") if @action
-
-        @controller = nil
-      end
     end
 
     private
-
-    # Sends the action to the controller if it exists
-    def controller_send(action_name)
-      if @controller.respond_to?(action_name)
-        @controller.send(action_name)
-      end
-    end
-
     # Fetch the controller class
     def get_controller(controller_path)
-      return nil, nil unless controller_path && controller_path.size > 0
+      raise "Invalid controller path: #{controller_path.inspect}" unless controller_path && controller_path.size > 0
 
       action = controller_path[-1]
 

data/lib/volt/page/targets/base_section.rb

@@ -17,8 +17,13 @@ module Volt
       fail 'not implemented'
     end
 
+    def set_template
+      fail 'not implemented'
+    end
+
     def set_content_to_template(page, template_name)
       if self.is_a?(DomSection)
+        # DomTemplates are an optimization when working with the DOM (as opposed to other targets)
         dom_template = (@@template_cache[template_name] ||= DomTemplate.new(page, template_name))
 
         set_template(dom_template)
@@ -29,7 +34,7 @@ module Volt
           html     = template['html']
           bindings = template['bindings']
         else
-          html     = "<div>-- &lt; missing template #{template_name.inspect.html_inspect}, make sure it's component is included in dependencies.rb &gt; --</div>"
+          html     = "<div>-- &lt; missing view or tag at #{template_name.inspect}, make sure it's component is included in dependencies.rb &gt; --</div>"
           bindings = {}
         end
 

data/lib/volt/page/targets/dom_template.rb

@@ -16,7 +16,7 @@ module Volt
         html      = template['html']
         @bindings = template['bindings']
       else
-        html      = "<div>-- &lt; missing template #{template_name.inspect.html_inspect}, make sure it's component is included in dependencies.rb &gt; --</div>"
+        html      = "<div>-- &lt; missing view or tag at #{template_name.inspect}, make sure it's component is included in dependencies.rb &gt; --</div>"
         @bindings = {}
       end
 

data/lib/volt/reactive/computation.rb

@@ -148,7 +148,7 @@ class Proc
   # @param the value to match
   # @return [Volt::Computation] the initial computation is returned.
   def watch_until!(value, &block)
-    computation = -> do
+    computation = Proc.new do |comp|
       # First fetch the value
       result = self.call
 
@@ -159,7 +159,7 @@ class Proc
         block.call
 
         # stop the computation
-        computation.stop
+        comp.stop
       end
     end.watch!
 

data/lib/volt/utils/generic_counting_pool.rb

@@ -24,7 +24,8 @@ module Volt
 
     # Lookups an item
     def lookup(*args, &block)
-      item = super(*args, &block)
+      # Note: must call without args because of https://github.com/opal/opal/issues/500
+      item = super
 
       item[1]
     end
@@ -34,12 +35,14 @@ module Volt
     end
 
     def remove(*args)
-      item    = __lookup(*args)
-      item[0] -= 1
-
-      if item[0] == 0
-        # Last one using this item has removed it.
-        super(*args)
+      item    = lookup_without_generate(*args)
+      if item
+        item[0] -= 1
+
+        if item[0] == 0
+          # Last one using this item has removed it.
+          super(*args)
+        end
       end
     end
   end

data/lib/volt/utils/generic_pool.rb

@@ -42,6 +42,18 @@ module Volt
       end
     end
 
+    # Looks up the path without generating a new one
+    def lookup_without_generate(*args)
+      section = @pool
+
+      args.each_with_index do |arg, index|
+        section = section[arg]
+        return nil unless section
+      end
+
+      section
+    end
+
     # Does the actual creating, if a block is not passed in, it calls
     # #create on the class.
     def create_new_item(*args)
@@ -97,6 +109,10 @@ module Volt
       end
     end
 
+    def inspect
+      "<#{self.class.to_s} #{@pool.inspect}>"
+    end
+
     def print
       puts '--- Running Queries ---'
 

data/spec/apps/kitchen_sink/app/main/config/routes.rb

@@ -8,6 +8,8 @@ client '/flash', action: 'flash'
 client '/yield', action: 'yield'
 client '/first_last', action: 'first_last'
 client '/todos', controller: 'todos'
+client '/html_safe', action: 'html_safe'
+client '/missing', action: 'missing'
 
 # Signup/login routes
 client '/signup', component: 'user_templates', controller: 'signup'

data/spec/apps/kitchen_sink/app/main/controllers/main_controller.rb

@@ -37,6 +37,10 @@ module Main
       'content'
     end
 
+    def example_html
+      '<button id="examplebutton">Example Button</button>'
+    end
+
     private
 
     # the main template contains a #template binding that shows another

data/spec/apps/kitchen_sink/app/main/views/main/html_safe.html

@@ -0,0 +1,7 @@
+<:Title>
+  HTML Safe
+
+<:Body>
+  <h1>Html Safe</h1>
+
+  {{ raw example_html }}

data/spec/apps/kitchen_sink/app/main/views/main/missing.html

@@ -0,0 +1,13 @@
+<:Title>
+  Missing Tag and View
+
+<:Body>
+  <h1>Missing Tag and View</h1>
+
+  {{ view 'some/wrong/path' }}
+
+  <hr />
+
+  <:not:a:component />
+
+

data/spec/controllers/actions_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+require 'volt/controllers/model_controller'
+
+class BaseTestActions
+  include Volt::Actions
+
+  setup_action_helpers_in_class(:before, :after)
+end
+
+class TestActionsBlocks < BaseTestActions
+  before_action do
+    @ran_before1 = true
+  end
+
+  before_action do
+    @ran_before2 = true
+  end
+
+  attr_reader :ran_before1, :ran_before2
+end
+
+class TestActionsSymbolsBase < BaseTestActions
+  attr_accessor :ran_one, :ran_two
+
+  def run_one
+    @ran_one = true
+  end
+
+  def run_two
+    @ran_two = true
+  end
+end
+
+class TestActionsSymbols < TestActionsSymbolsBase
+  before_action :run_one
+  before_action :run_two
+end
+
+class TestActions2 < BaseTestActions
+end
+
+class TestActionsMultipleSymbols < TestActionsSymbolsBase
+  before_action :run_one, :run_two
+end
+
+# Runs three actions, stopping the chanin after one
+class TestStopCallbacks < BaseTestActions
+  before_action :run_one, :run_two, :run_three
+  attr_accessor :ran_one, :ran_two, :ran_end_of_two, :ran_three
+
+  def run_one
+    @ran_one = true
+  end
+
+  def run_two
+    @ran_two = true
+    stop_chain
+    @ran_end_of_two = true
+  end
+
+  def run_three
+    @ran_three = true
+  end
+end
+
+class TestNoCallbacks < BaseTestActions
+end
+
+class TestOnlyCallbacks < TestActionsSymbolsBase
+  before_action :run_one, :run_two, only: [:new]
+end
+
+describe Volt::Actions do
+  it 'should trigger before actions via blocks' do
+    test_class = TestActionsBlocks.new
+
+    expect(test_class.ran_before1).to eq(nil)
+    expect(test_class.ran_before2).to eq(nil)
+
+    test_class.run_actions(:before, :index)
+
+    expect(test_class.ran_before1).to eq(true)
+    expect(test_class.ran_before2).to eq(true)
+  end
+
+  it 'should trigger before actions via symbols' do
+    test_class = TestActionsSymbols.new
+
+    expect(test_class.ran_one).to eq(nil)
+    expect(test_class.ran_two).to eq(nil)
+
+    test_class.run_actions(:before, :index)
+
+    expect(test_class.ran_one).to eq(true)
+    expect(test_class.ran_two).to eq(true)
+
+  end
+
+  it 'should raise an exception if no symbol or block is provided' do
+    expect do
+      TestActions2.before_action
+    end.to raise_error(RuntimeError, "No callback symbol or block provided")
+  end
+
+  it 'should support multiple symbols passed an action helper' do
+    test_class = TestActionsMultipleSymbols.new
+
+    expect(test_class.ran_one).to eq(nil)
+    expect(test_class.ran_two).to eq(nil)
+
+    result = test_class.run_actions(:before, :index)
+    expect(result).to eq(false)
+
+    expect(test_class.ran_one).to eq(true)
+    expect(test_class.ran_two).to eq(true)
+  end
+
+  it 'should stop the chain when #stop_chain is called and return false from #run_actions' do
+   test_class = TestStopCallbacks.new
+
+   result = test_class.run_actions(:before, :index)
+   expect(result).to eq(true)
+
+   expect(test_class.ran_one).to eq(true)
+   expect(test_class.ran_two).to eq(true)
+   expect(test_class.ran_end_of_two).to eq(nil)
+   expect(test_class.ran_three).to eq(nil)
+  end
+
+  it 'should call without any callbacks' do
+    test_class = TestNoCallbacks.new
+
+    result = test_class.run_actions(:before, :index)
+    expect(result).to eq(false)
+  end
+
+  it 'should follow only limitations' do
+    test_only = TestOnlyCallbacks.new
+
+    test_only.run_actions(:before, :index)
+    expect(test_only.ran_one).to eq(nil)
+    expect(test_only.ran_two).to eq(nil)
+
+    test_only.run_actions(:before, :new)
+    expect(test_only.ran_one).to eq(true)
+    expect(test_only.ran_two).to eq(true)
+  end
+end

data/spec/controllers/model_controller_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+if RUBY_PLATFORM != 'opal'
+  describe Volt::ModelController do
+    it 'should accept a promise as a model and resolve it' do
+      controller = Volt::ModelController.new
+
+      promise = Promise.new
+
+      controller.model = promise
+
+      expect(controller.model).to eq(nil)
+
+      promise.resolve(20)
+
+      expect(controller.model).to eq(20)
+    end
+
+    it 'should not return true from loaded until the promise is resolved' do
+      controller = Volt::ModelController.new
+
+      promise = Promise.new
+      controller.model = promise
+
+      expect(controller.loaded?).to eq(false)
+
+      promise.resolve(Volt::Model.new)
+      expect(controller.loaded?).to eq(true)
+    end
+  end
+end

data/spec/integration/missing_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe "missing tags and view's", type: :feature do
+  it 'should show a message about the missing tag/view' do
+    visit '/missing'
+
+    expect(page).to have_content('view or tag at "some/wrong/path"')
+    expect(page).to have_content('view or tag at "not/a/component"')
+
+  end
+end

data/spec/integration/raw_html_binding.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "HTML safe/raw", type: :feature do
+  it 'should render html with the raw helper' do
+    visit '/html_safe'
+
+    expect(page).to have_selector('button[id="examplebutton"]')
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: volt
 version: !ruby/object:Gem::Version
-  version: 0.9.0.pre4
+  version: 0.9.0.pre5
 platform: ruby
 authors:
 - Ryan Stout
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-10 00:00:00.000000000 Z
+date: 2015-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -480,6 +480,7 @@ files:
 - lib/volt/cli/new_gem.rb
 - lib/volt/cli/runner.rb
 - lib/volt/config.rb
+- lib/volt/controllers/actions.rb
 - lib/volt/controllers/http_controller.rb
 - lib/volt/controllers/model_controller.rb
 - lib/volt/data_stores/data_store.rb
@@ -544,8 +545,10 @@ files:
 - lib/volt/page/bindings/content_binding.rb
 - lib/volt/page/bindings/each_binding.rb
 - lib/volt/page/bindings/event_binding.rb
+- lib/volt/page/bindings/html_safe/string_extension.rb
 - lib/volt/page/bindings/if_binding.rb
 - lib/volt/page/bindings/view_binding.rb
+- lib/volt/page/bindings/view_binding/controller_handler.rb
 - lib/volt/page/bindings/view_binding/grouped_controllers.rb
 - lib/volt/page/bindings/view_binding/view_lookup_for_path.rb
 - lib/volt/page/bindings/yield_binding.rb
@@ -646,8 +649,10 @@ files:
 - spec/apps/kitchen_sink/app/main/views/main/cookie_test.html
 - spec/apps/kitchen_sink/app/main/views/main/first_last.html
 - spec/apps/kitchen_sink/app/main/views/main/flash.html
+- spec/apps/kitchen_sink/app/main/views/main/html_safe.html
 - spec/apps/kitchen_sink/app/main/views/main/index.html
 - spec/apps/kitchen_sink/app/main/views/main/main.html
+- spec/apps/kitchen_sink/app/main/views/main/missing.html
 - spec/apps/kitchen_sink/app/main/views/main/store.html
 - spec/apps/kitchen_sink/app/main/views/main/yield.html
 - spec/apps/kitchen_sink/app/main/views/todos/index.html
@@ -656,7 +661,9 @@ files:
 - spec/apps/kitchen_sink/config.ru
 - spec/apps/kitchen_sink/config/app.rb
 - spec/apps/kitchen_sink/config/base/index.html
+- spec/controllers/actions_spec.rb
 - spec/controllers/http_controller_spec.rb
+- spec/controllers/model_controller_spec.rb
 - spec/controllers/reactive_accessors_spec.rb
 - spec/extra_core/array_spec.rb
 - spec/extra_core/blank_spec.rb
@@ -673,6 +680,8 @@ files:
 - spec/integration/flash_spec.rb
 - spec/integration/http_endpoints_spec.rb
 - spec/integration/list_spec.rb
+- spec/integration/missing_spec.rb
+- spec/integration/raw_html_binding.rb
 - spec/integration/templates_spec.rb
 - spec/integration/url_spec.rb
 - spec/integration/user_spec.rb
@@ -849,8 +858,10 @@ test_files:
 - spec/apps/kitchen_sink/app/main/views/main/cookie_test.html
 - spec/apps/kitchen_sink/app/main/views/main/first_last.html
 - spec/apps/kitchen_sink/app/main/views/main/flash.html
+- spec/apps/kitchen_sink/app/main/views/main/html_safe.html
 - spec/apps/kitchen_sink/app/main/views/main/index.html
 - spec/apps/kitchen_sink/app/main/views/main/main.html
+- spec/apps/kitchen_sink/app/main/views/main/missing.html
 - spec/apps/kitchen_sink/app/main/views/main/store.html
 - spec/apps/kitchen_sink/app/main/views/main/yield.html
 - spec/apps/kitchen_sink/app/main/views/todos/index.html
@@ -859,7 +870,9 @@ test_files:
 - spec/apps/kitchen_sink/config.ru
 - spec/apps/kitchen_sink/config/app.rb
 - spec/apps/kitchen_sink/config/base/index.html
+- spec/controllers/actions_spec.rb
 - spec/controllers/http_controller_spec.rb
+- spec/controllers/model_controller_spec.rb
 - spec/controllers/reactive_accessors_spec.rb
 - spec/extra_core/array_spec.rb
 - spec/extra_core/blank_spec.rb
@@ -876,6 +889,8 @@ test_files:
 - spec/integration/flash_spec.rb
 - spec/integration/http_endpoints_spec.rb
 - spec/integration/list_spec.rb
+- spec/integration/missing_spec.rb
+- spec/integration/raw_html_binding.rb
 - spec/integration/templates_spec.rb
 - spec/integration/url_spec.rb
 - spec/integration/user_spec.rb