volt 0.8.14 → 0.8.15

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

@@ -2,235 +2,232 @@ require 'volt/page/bindings/base_binding'
 require 'volt/page/template_renderer'
 require 'volt/page/bindings/template_binding/grouped_controllers'
 
-class TemplateBinding < BaseBinding
-  def initialize(page, target, context, binding_name, binding_in_path, getter)
-    super(page, target, context, binding_name)
-
-    # Binding in path is the path for the template this binding is in
-    setup_path(binding_in_path)
-
-    @current_template = nil
-
-    # Run the initial render
-    @computation = -> do
-      # Don't try to render if this has been removed
-      if @context
-        # Render
-        update(*@context.instance_eval(&getter))
-      end
-    end.watch!
-  end
+module Volt
+  class TemplateBinding < BaseBinding
+    def initialize(page, target, context, binding_name, binding_in_path, getter)
+      super(page, target, context, binding_name)
+
+      # Binding in path is the path for the template this binding is in
+      setup_path(binding_in_path)
+
+      @current_template = nil
+
+      # Run the initial render
+      @computation      = -> do
+        # Don't try to render if this has been removed
+        if @context
+          # Render
+          update(*@context.instance_eval(&getter))
+        end
+      end.watch!
+    end
 
-  def setup_path(binding_in_path)
-    path_parts = binding_in_path.split('/')
-    @collection_name = path_parts[0]
-    @controller_name = path_parts[1]
-    @page_name = path_parts[2]
-  end
+    def setup_path(binding_in_path)
+      path_parts       = binding_in_path.split('/')
+      @collection_name = path_parts[0]
+      @controller_name = path_parts[1]
+      @page_name       = path_parts[2]
+    end
 
-  # Returns true if there is a template at the path
-  def check_for_template?(path)
-    @page.templates[path]
-  end
+    # Returns true if there is a template at the path
+    def check_for_template?(path)
+      @page.templates[path]
+    end
 
-  # Takes in a lookup path and returns the full path for the matching
-  # template.  Also returns the controller and action name if applicable.
-  #
-  # Looking up a path is fairly simple.  There are 4 parts needed to find
-  # the html to be rendered.  File paths look like this:
-  # app/{component}/views/{controller_name}/{view}.html
-  # Within the html file may be one or more sections.
-  # 1. component (app/{comp})
-  # 2. controller
-  # 3. view
-  # 4. sections
-  #
-  # When searching for a file, the lookup starts at the section, and moves up.
-  # when moving up, default values are provided for the section, then view/section, etc..
-  # until a file is either found or the component level is reached.
-  #
-  # The defaults are as follows:
-  # 1. component - main
-  # 2. controller - main
-  # 3. view - main
-  # 4. section - body
-  def path_for_template(lookup_path, force_section=nil)
-    parts = lookup_path.split('/')
-    parts_size = parts.size
-
-    default_parts = ['main', 'main', 'index', 'body']
-
-    # When forcing a sub template, we can default the sub template section
-    default_parts[-1] = force_section if force_section
-
-    (5 - parts_size).times do |path_position|
-      # If they passed in a force_section, we can skip the first
-      next if force_section && path_position == 0
-
-      full_path = [@collection_name, @controller_name, @page_name, nil]
-
-      start_at = full_path.size - parts_size - path_position
-
-      full_path.size.times do |index|
-        if index >= start_at
-          if part = parts[index-start_at]
-            full_path[index] = part
-          else
-            full_path[index] = default_parts[index]
+    # Takes in a lookup path and returns the full path for the matching
+    # template.  Also returns the controller and action name if applicable.
+    #
+    # Looking up a path is fairly simple.  There are 4 parts needed to find
+    # the html to be rendered.  File paths look like this:
+    # app/{component}/views/{controller_name}/{view}.html
+    # Within the html file may be one or more sections.
+    # 1. component (app/{comp})
+    # 2. controller
+    # 3. view
+    # 4. sections
+    #
+    # When searching for a file, the lookup starts at the section, and moves up.
+    # when moving up, default values are provided for the section, then view/section, etc..
+    # until a file is either found or the component level is reached.
+    #
+    # The defaults are as follows:
+    # 1. component - main
+    # 2. controller - main
+    # 3. view - main
+    # 4. section - body
+    def path_for_template(lookup_path, force_section=nil)
+      parts      = lookup_path.split('/')
+      parts_size = parts.size
+
+      default_parts     = ['main', 'main', 'index', 'body']
+
+      # When forcing a sub template, we can default the sub template section
+      default_parts[-1] = force_section if force_section
+
+      (5 - parts_size).times do |path_position|
+        # If they passed in a force_section, we can skip the first
+        next if force_section && path_position == 0
+
+        full_path = [@collection_name, @controller_name, @page_name, nil]
+
+        start_at = full_path.size - parts_size - path_position
+
+        full_path.size.times do |index|
+          if index >= start_at
+            if (part = parts[index - start_at])
+              full_path[index] = part
+            else
+              full_path[index] = default_parts[index]
+            end
           end
         end
-      end
 
-      path = full_path.join('/')
-      if check_for_template?(path)
-        controller = nil
+        path = full_path.join('/')
+        if check_for_template?(path)
+          controller = nil
 
-        # Don't return a controller if we are just getting another section
-        # from the same controller
-        if path_position >= 1
-          # Lookup the controller
-          controller = [full_path[0], full_path[1] + '_controller', full_path[2]]
+          # Don't return a controller if we are just getting another section
+          # from the same controller
+          if path_position >= 1
+            # Lookup the controller
+            controller = [full_path[0], full_path[1] + '_controller', full_path[2]]
+          end
+          return path, controller
         end
-        return path, controller
       end
+
+      return nil, nil
     end
 
-    return nil, nil
-  end
+    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
+        @current_template.remove if @current_template
 
-  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
-      @current_template.remove if @current_template
+        @options = options
 
-      @options = options
+        # A blank path needs to load a missing template, otherwise it tries to load
+        # the same template.
+        path     = path.blank? ? '---missing---' : path
 
-      # A blank path needs to load a missing template, otherwise it tries to load
-      # the same template.
-      path = path.blank? ? '---missing---' : path
+        section    = nil
+        @arguments = nil
 
-      section = nil
-      @arguments = nil
+        if section_or_arguments.is_a?(String)
+          # Render this as a section
+          section = section_or_arguments
+        else
+          # Use the value passed in as the default arguments
+          @arguments = section_or_arguments
+        end
 
-      if section_or_arguments.is_a?(String)
-        # Render this as a section
-        section = section_or_arguments
-      else
-        # Use the value passed in as the default arguments
-        @arguments = section_or_arguments
+        # 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])
+          @grouped_controller = GroupedControllers.new(controller_group)
+        else
+          clear_grouped_controller
+        end
+
+        full_path, controller_path = path_for_template(path, section)
+        render_template(full_path, controller_path)
+
+        queue_clear_grouped_controller
       end
+    end
 
-      # 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])
-        @grouped_controller = GroupedControllers.new(controller_group)
+    # On the next tick, we clear the grouped controller so that any changes to template paths
+    # will create a new controller and trigger the action.
+    def queue_clear_grouped_controller
+      if Volt.in_browser?
+        # In the browser, we want to keep a grouped controller around during a single run
+        # of the event loop.  To make that happen, we clear it on the next tick.
+        `setImmediate(function() {`
+          clear_grouped_controller
+        `});`
       else
+        # For the backend, clear it immediately
         clear_grouped_controller
       end
-
-      full_path, controller_path = path_for_template(path, section)
-      render_template(full_path, controller_path)
-
-      queue_clear_grouped_controller
     end
-  end
 
-  # On the next tick, we clear the grouped controller so that any changes to template paths
-  # will create a new controller and trigger the action.
-  def queue_clear_grouped_controller
-    if Volt.in_browser?
-      # In the browser, we want to keep a grouped controller around during a single run
-      # of the event loop.  To make that happen, we clear it on the next tick.
-      `setImmediate(function() {`
-        clear_grouped_controller
-      `})`
-    else
-      # For the backend, clear it immediately
-      clear_grouped_controller
+    def clear_grouped_controller
+      if @grouped_controller
+        @grouped_controller.clear
+        @grouped_controller = nil
+      end
     end
-  end
 
-  def clear_grouped_controller
-    if @grouped_controller
-      @grouped_controller.clear
-      @grouped_controller = nil
-    end
-  end
+    # The context for templates can be either a controller, or the original context.
+    def render_template(full_path, controller_path)
+      args = @arguments ? [SubContext.new(@arguments)] : []
 
-  # The context for templates can be either a controller, or the original context.
-  def render_template(full_path, controller_path)
-    if @arguments
-      args = [SubContext.new(@arguments)]
-    else
-      args = []
-    end
+      @controller = nil
+
+      # Fetch grouped controllers if we're grouping
+      @controller = @grouped_controller.get if @grouped_controller
 
-    @controller = nil
+      # The action to be called and rendered
+      @action     = nil
 
-    # Fetch grouped controllers if we're grouping
-    @controller = @grouped_controller.get if @grouped_controller
+      if @controller
+        # Track that we're using the group controller
+        @grouped_controller.inc if @grouped_controller
+      else
+        # Otherwise, make a new controller
+        controller_class, @action = get_controller(controller_path)
 
-    # The action to be called and rendered
-    @action = nil
+        if controller_class
+          # Setup the controller
+          @controller = controller_class.new(*args)
+        else
+          @controller = ModelController.new(*args)
+        end
 
-    if @controller
-      # Track that we're using the group controller
-      @grouped_controller.inc if @grouped_controller
-    else
-      # Otherwise, make a new controller
-      controller_class, @action = get_controller(controller_path)
+        # Trigger the action
+        controller_send(@action) if @action
 
-      if controller_class
-        # Setup the controller
-        @controller = controller_class.new(*args)
-      else
-        @controller = ModelController.new(*args)
+        # Track the grouped controller
+        @grouped_controller.set(@controller) if @grouped_controller
       end
 
-      # Trigger the action
-      controller_send(@action) if @action
+      @current_template = TemplateRenderer.new(@page, @target, @controller, @binding_name, full_path)
 
-      # Track the grouped controller
-      @grouped_controller.set(@controller) if @grouped_controller
+      call_ready
     end
 
-    @current_template = TemplateRenderer.new(@page, @target, @controller, @binding_name, full_path)
-
-    call_ready
-  end
+    def call_ready
+      if @controller
+        # Set the current section on the controller if it wants so it can manipulate
+        # the dom if needed
+        if @controller.respond_to?(:section=)
+          @controller.section = @current_template.dom_section
+        end
 
-  def call_ready
-    if @controller
-      # Set the current section on the controller if it wants so it can manipulate
-      # the dom if needed
-      if @controller.respond_to?(:section=)
-        @controller.section = @current_template.dom_section
+        controller_send(:"#{@action}_ready") if @action
       end
-
-      controller_send(:"#{@action}_ready") if @action
     end
-  end
 
-  def remove
-    clear_grouped_controller
+    def remove
+      clear_grouped_controller
 
-    if @current_template
-      # Remove the template if one has been rendered, when the template binding is
-      # removed.
-      @current_template.remove
-    end
+      if @current_template
+        # Remove the template if one has been rendered, when the template binding is
+        # removed.
+        @current_template.remove
+      end
 
-    super
+      super
 
-    if @controller
-      controller_send(:"#{@action}_removed") if @action
+      if @controller
+        controller_send(:"#{@action}_removed") if @action
 
-      @controller = nil
+        @controller = nil
+      end
     end
-  end
 
-  private
+    private
     # Sends the action to the controller if it exists
     def controller_send(action_name)
       if @controller.respond_to?(action_name)
@@ -245,7 +242,7 @@ class TemplateBinding < BaseBinding
       action = controller_path[-1]
 
       # Get the constant parts
-      parts = controller_path[0..-2].map {|v| v.gsub('-', '_').camelize }
+      parts  = controller_path[0..-2].map { |v| v.gsub('-', '_').camelize }
 
       # Home doesn't get namespaced
       if parts.first == 'Main'
@@ -265,5 +262,5 @@ class TemplateBinding < BaseBinding
 
       return obj, action
     end
-
+  end
 end

data/lib/volt/page/channel.rb

@@ -4,101 +4,103 @@ require 'json'
 require 'volt/reactive/reactive_accessors'
 require 'volt/reactive/eventable'
 
-class Channel
-  include ReactiveAccessors
-  include Eventable
-
-  reactive_accessor :connected, :status, :error, :reconnect_interval, :retry_count
+module Volt
+  class Channel
+    include ReactiveAccessors
+    include Eventable
+
+    reactive_accessor :connected, :status, :error, :reconnect_interval, :retry_count
+
+    def initialize
+      @socket          = nil
+      self.status      = :opening
+      self.connected   = false
+      self.error       = nil
+      self.retry_count = 0
+      @queue           = []
+
+      connect!
+    end
 
-  def initialize
-    @socket = nil
-    self.status = :opening
-    self.connected = false
-    self.error = nil
-    self.retry_count = 0
-    @queue = []
+    def connected?
+      self.connected
+    end
 
-    connect!
-  end
+    def connect!
+      %x{
+        this.socket = new SockJS('/channel');
 
-  def connected?
-    self.connected
-  end
+        this.socket.onopen = function() {
+          self.$opened();
+        };
 
-  def connect!
-    %x{
-      this.socket = new SockJS('/channel');
+        this.socket.onmessage = function(message) {
+          self['$message_received'](message.data);
+        };
 
-      this.socket.onopen = function() {
-        self.$opened();
-      };
+        this.socket.onclose = function(error) {
+          self.$closed(error);
+        };
+      }
+    end
 
-      this.socket.onmessage = function(message) {
-        self['$message_received'](message.data);
-      };
+    def opened
+      old_status          = @status
+      @status             = :open
+      @connected          = true
+      @reconnect_interval = nil
+      @retry_count        = 0
+      @queue.each do |message|
+        send_message(message)
+      end
+    end
 
-      this.socket.onclose = function(error) {
-        self.$closed(error);
-      };
-    }
-  end
+    def closed(error)
+      self.status    = :closed
+      self.connected = false
+      self.error     = `error.reason`
 
-  def opened
-    old_status = @status
-    @status = :open
-    @connected = true
-    @reconnect_interval = nil
-    @retry_count = 0
-    @queue.each do |message|
-      send_message(message)
+      reconnect!
     end
-  end
 
-  def closed(error)
-    self.status = :closed
-    self.connected = false
-    self.error = `error.reason`
+    def reconnect!
+      self.status             = :reconnecting
+      self.reconnect_interval ||= 0
+      self.reconnect_interval += (2000 + rand(5000))
+      self.retry_count        += 1
 
-    reconnect!
-  end
-
-  def reconnect!
-    self.status = :reconnecting
-    self.reconnect_interval ||= 0
-    self.reconnect_interval += (2000 + rand(5000))
-    self.retry_count += 1
+      interval = self.reconnect_interval
 
-    interval = self.reconnect_interval
+      %x{
+        setTimeout(function() {
+          self['$connect!']();
+        }, interval);
+      }
+    end
 
-    %x{
-      setTimeout(function() {
-        self['$connect!']();
-      }, interval);
-    }
-  end
+    def message_received(message)
+      message = JSON.parse(message)
 
-  def message_received(message)
-    message = JSON.parse(message)
+      trigger!('message', *message)
+    end
 
-    trigger!('message', *message)
-  end
+    def send_message(message)
+      if self.status != :open
+        @queue << message
+      else
+        # TODO: Temp: wrap message in an array, so we're sure its valid JSON
+        message = JSON.dump([message])
+        %x{
+          this.socket.send(message);
+        }
+      end
+    end
 
-  def send_message(message)
-    if self.status != :open
-      @queue << message
-    else
-      # TODO: Temp: wrap message in an array, so we're sure its valid JSON
-      message = JSON.dump([message])
+    def close!
+      self.status = :closed
       %x{
-        this.socket.send(message);
+        this.socket.close();
       }
     end
   end
-
-  def close!
-    self.status = :closed
-    %x{
-      this.socket.close();
-    }
-  end
 end

data/lib/volt/page/channel_stub.rb

@@ -4,32 +4,34 @@
 require 'volt/tasks/dispatcher'
 require 'volt/reactive/eventable'
 
-# Behaves the same as the Channel class, only the Channel class uses
-# sockjs to pass messages to the backend.  ChannelStub, simply passes
-# them directly to SocketConnectionHandlerStub.
-class ChannelStub
-  include Eventable
-
-  attr_reader :state, :error, :reconnect_interval
-
-  def initiailze
-    @state = :connected
-  end
-
-  def opened
-    trigger!('open')
-    trigger!('changed')
-  end
-
-  def message_received(*message)
-    trigger!('message', *message)
-  end
-
-  def send_message(message)
-    SocketConnectionHandlerStub.new(self).process_message(message)
-  end
-
-  def close!
-    raise "close! should not be called on the backend channel"
+module Volt
+  # Behaves the same as the Channel class, only the Channel class uses
+  # sockjs to pass messages to the backend.  ChannelStub, simply passes
+  # them directly to SocketConnectionHandlerStub.
+  class ChannelStub
+    include Eventable
+
+    attr_reader :state, :error, :reconnect_interval
+
+    def initiailze
+      @state = :connected
+    end
+
+    def opened
+      trigger!('open')
+      trigger!('changed')
+    end
+
+    def message_received(*message)
+      trigger!('message', *message)
+    end
+
+    def send_message(message)
+      SocketConnectionHandlerStub.new(self).process_message(message)
+    end
+
+    def close!
+      raise "close! should not be called on the backend channel"
+    end
   end
 end