volt 0.8.14 → 0.8.15

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

@@ -1,151 +1,151 @@
 require 'volt/page/bindings/base_binding'
 
-class EachBinding < BaseBinding
-  def initialize(page, target, context, binding_name, getter, variable_name, template_name)
-    super(page, target, context, binding_name)
+module Volt
+  class EachBinding < BaseBinding
+    def initialize(page, target, context, binding_name, getter, variable_name, template_name)
+      super(page, target, context, binding_name)
 
-    @item_name = variable_name
-    @template_name = template_name
+      @item_name     = variable_name
+      @template_name = template_name
 
-    @templates = []
+      @templates = []
 
-    @getter = getter
+      @getter      = getter
 
-    # Listen for changes
-    @computation = -> { reload }.watch!
-  end
-
-  # When a changed event happens, we update to the new size.
-  def reload
-    begin
-      value = @context.instance_eval(&@getter)
-    rescue => e
-      Volt.logger.error("EachBinding Error: #{e.inspect}")
-      value = []
+      # Listen for changes
+      @computation = -> { reload }.watch!
     end
 
-    # Since we're checking things like size, we don't want this to be re-triggered on a
-    # size change, so we run without tracking.
-    Computation.run_without_tracking do
-      # puts "RELOAD:-------------- #{value.inspect}"
-      # Adjust to the new size
-      values = current_values(value)
-      @value = values
-
-      @added_listener.remove if @added_listener
-      @removed_listener.remove if @removed_listener
-
-      if @value.respond_to?(:on)
-        @added_listener = @value.on('added') { |position| item_added(position) }
-        @removed_listener = @value.on('removed') { |position| item_removed(position) }
+    # When a changed event happens, we update to the new size.
+    def reload
+      begin
+        value = @context.instance_eval(&@getter)
+      rescue => e
+        Volt.logger.error("EachBinding Error: #{e.inspect}")
+        value = []
       end
 
-      templates_size = @templates.size
-      values_size = values.size
-
-      # Start over, re-create all nodes
-      (templates_size-1).downto(0) do |index|
-        item_removed(index)
-      end
-      0.upto(values_size-1) do |index|
-        item_added(index)
+      # Since we're checking things like size, we don't want this to be re-triggered on a
+      # size change, so we run without tracking.
+      Computation.run_without_tracking do
+        # puts "RELOAD:-------------- #{value.inspect}"
+        # Adjust to the new size
+        values = current_values(value)
+        @value = values
+
+        @added_listener.remove if @added_listener
+        @removed_listener.remove if @removed_listener
+
+        if @value.respond_to?(:on)
+          @added_listener   = @value.on('added') { |position| item_added(position) }
+          @removed_listener = @value.on('removed') { |position| item_removed(position) }
+        end
+
+        templates_size = @templates.size
+        values_size    = values.size
+
+        # Start over, re-create all nodes
+        (templates_size-1).downto(0) do |index|
+          item_removed(index)
+        end
+        0.upto(values_size-1) do |index|
+          item_added(index)
+        end
       end
     end
-  end
 
-  def item_removed(position)
-    # Remove dependency
-    @templates[position].context.locals[:index_dependency].remove
+    def item_removed(position)
+      # Remove dependency
+      @templates[position].context.locals[:index_dependency].remove
 
-    # puts "REMOVE AT: #{position.inspect} - #{@templates[position].inspect} - #{@templates.inspect}"
-    @templates[position].remove_anchors
-    @templates[position].remove
-    @templates.delete_at(position)
+      # puts "REMOVE AT: #{position.inspect} - #{@templates[position].inspect} - #{@templates.inspect}"
+      @templates[position].remove_anchors
+      @templates[position].remove
+      @templates.delete_at(position)
 
-    # Removed at the position, update context for every item after this position
-    update_indexes_after(position)
-  end
+      # Removed at the position, update context for every item after this position
+      update_indexes_after(position)
+    end
 
-  def item_added(position)
-    binding_name = @@binding_number
-    @@binding_number += 1
+    def item_added(position)
+      binding_name     = @@binding_number
+      @@binding_number += 1
 
-    if position >= @templates.size
-      # Setup new bindings in the spot we want to insert the item
-      dom_section.insert_anchor_before_end(binding_name)
-    else
-      # Insert the item before an existing item
-      dom_section.insert_anchor_before(binding_name, @templates[position].binding_name)
-    end
+      if position >= @templates.size
+        # Setup new bindings in the spot we want to insert the item
+        dom_section.insert_anchor_before_end(binding_name)
+      else
+        # Insert the item before an existing item
+        dom_section.insert_anchor_before(binding_name, @templates[position].binding_name)
+      end
 
-    # TODORW: :parent => @value may change
-    item_context = SubContext.new({:_index_value => position, :parent => @value}, @context)
-    item_context.locals[@item_name.to_sym] = Proc.new { @value[item_context.locals[:_index_value]] }
+      # TODORW: :parent => @value may change
+      item_context                           = SubContext.new({:_index_value => position, :parent => @value}, @context)
+      item_context.locals[@item_name.to_sym] = Proc.new { @value[item_context.locals[:_index_value]] }
 
-    position_dependency = Dependency.new
-    item_context.locals[:index_dependency] = position_dependency
+      position_dependency                    = Dependency.new
+      item_context.locals[:index_dependency] = position_dependency
 
-    # Get and set index
-    item_context.locals[:index=] = Proc.new do |val|
-      position_dependency.changed!
-      item_context.locals[:_index_value] = val
-    end
+      # Get and set index
+      item_context.locals[:index=]           = Proc.new do |val|
+        position_dependency.changed!
+        item_context.locals[:_index_value] = val
+      end
 
-    item_context.locals[:index] = Proc.new do
-      position_dependency.depend
-      item_context.locals[:_index_value]
-    end
+      item_context.locals[:index] = Proc.new do
+        position_dependency.depend
+        item_context.locals[:_index_value]
+      end
 
-    item_template = TemplateRenderer.new(@page, @target, item_context, binding_name, @template_name)
-    @templates.insert(position, item_template)
+      item_template = TemplateRenderer.new(@page, @target, item_context, binding_name, @template_name)
+      @templates.insert(position, item_template)
 
-    update_indexes_after(position)
-  end
+      update_indexes_after(position)
+    end
 
-  # When items are added or removed in the middle of the list, we need
-  # to update each templates index value.
-  def update_indexes_after(start_index)
-    size = @templates.size
-    if size > 0
-      start_index.upto(size-1) do |index|
-        @templates[index].context.locals[:index=].call(index)
+    # When items are added or removed in the middle of the list, we need
+    # to update each templates index value.
+    def update_indexes_after(start_index)
+      size = @templates.size
+      if size > 0
+        start_index.upto(size-1) do |index|
+          @templates[index].context.locals[:index=].call(index)
+        end
       end
     end
-  end
 
-  def current_values(values)
-    return [] if values.is_a?(Model) || values.is_a?(Exception)
-    values = values.attributes if values.respond_to?(:attributes)
+    def current_values(values)
+      return [] if values.is_a?(Model) || values.is_a?(Exception)
+      values = values.attributes if values.respond_to?(:attributes)
 
-    return values
-  end
+      return values
+    end
 
 
-  # When this each_binding is removed, cleanup.
-  def remove
-    @computation.stop
-    @computation = nil
+    # When this each_binding is removed, cleanup.
+    def remove
+      @computation.stop
+      @computation = nil
 
-    # Clear value
-    @value = nil
+      # Clear value
+      @value       = nil
 
-    @added_listener.remove
-    @added_listener = nil
+      @added_listener.remove
+      @added_listener = nil
 
-    @removed_listener.remove
-    @removed_listener = nil
+      @removed_listener.remove
+      @removed_listener = nil
 
-    if @templates
-      template_count = @templates.size
-      template_count.times do |index|
-        item_removed(template_count - index - 1)
+      if @templates
+        template_count = @templates.size
+        template_count.times do |index|
+          item_removed(template_count - index - 1)
+        end
+        # @templates.compact.each(&:remove)
+        @templates = nil
       end
-      # @templates.compact.each(&:remove)
-      @templates = nil
-    end
 
-    super
+      super
+    end
   end
-
-
 end

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

@@ -1,50 +1,54 @@
 require 'volt/page/bindings/base_binding'
 
+module Volt
 # TODO: We need to figure out how we want to wrap JS events
-class JSEvent
-  attr_reader :js_event
-  def initialize(js_event)
-    @js_event = js_event
-  end
+  class JSEvent
+    attr_reader :js_event
 
-  def key_code
-    `this.js_event.keyCode`
-  end
+    def initialize(js_event)
+      @js_event = js_event
+    end
 
-  def stop!
-    `this.js_event.stopPropagation();`
-  end
+    def key_code
+      `this.js_event.keyCode`
+    end
 
-  def prevent_default!
-    `this.js_event.preventDefault();`
-  end
+    def stop!
+      `this.js_event.stopPropagation();`
+    end
+
+    def prevent_default!
+      `this.js_event.preventDefault();`
+    end
 
-  def target
-    `this.js_event.toElement`
+    def target
+      `this.js_event.toElement`
+    end
   end
-end
 
 
-class EventBinding < BaseBinding
-  attr_accessor :context, :binding_name
-  def initialize(page, target, context, binding_name, event_name, call_proc)
-    super(page, target, context, binding_name)
-    @event_name = event_name
+  class EventBinding < BaseBinding
+    attr_accessor :context, :binding_name
 
-    handler = Proc.new do |js_event|
-      event = JSEvent.new(js_event)
-      event.prevent_default! if event_name == 'submit'
+    def initialize(page, target, context, binding_name, event_name, call_proc)
+      super(page, target, context, binding_name)
+      @event_name = event_name
 
-      # Call the proc the user setup for the event in context,
-      # pass in the wrapper for the JS event
-      result = @context.instance_exec(event, &call_proc)
-    end
+      handler = Proc.new do |js_event|
+        event = JSEvent.new(js_event)
+        event.prevent_default! if event_name == 'submit'
 
-    @listener = @page.events.add(event_name, self, handler)
-  end
+        # Call the proc the user setup for the event in context,
+        # pass in the wrapper for the JS event
+        result = @context.instance_exec(event, &call_proc)
+      end
+
+      @listener = @page.events.add(event_name, self, handler)
+    end
 
-  # Remove the event binding
-  def remove
-    @page.events.remove(@event_name, self)
+    # Remove the event binding
+    def remove
+      @page.events.remove(@event_name, self)
+    end
   end
 end

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

@@ -1,77 +1,79 @@
 require 'volt/page/bindings/base_binding'
 
-class IfBinding < BaseBinding
-  def initialize(page, target, context, binding_name, branches)
-    super(page, target, context, binding_name)
+module Volt
+  class IfBinding < BaseBinding
+    def initialize(page, target, context, binding_name, branches)
+      super(page, target, context, binding_name)
 
-    getter, template_name = branches[0]
+      getter, template_name = branches[0]
 
-    @branches = []
-    @listeners = []
+      @branches  = []
+      @listeners = []
 
-    branches.each do |branch|
-      getter, template_name = branch
+      branches.each do |branch|
+        getter, template_name = branch
 
-      if getter.present?
-        value = getter
-      else
-        # A nil value means this is an unconditional else branch, it
-        # should always be true
-        value = true
+        if getter.present?
+          value = getter
+        else
+          # A nil value means this is an unconditional else branch, it
+          # should always be true
+          value = true
+        end
+
+        @branches << [value, template_name]
       end
 
-      @branches << [value, template_name]
+      @computation = -> { update }.watch!
     end
 
-    @computation = -> { update }.watch!
-  end
-
-  def update
-    # Find the true branch
-    true_template = nil
-    @branches.each do |branch|
-      value, template_name = branch
-
-      if value.is_a?(Proc)
-        begin
-          current_value = @context.instance_eval(&value)
-        rescue => e
-          Volt.logger.error("IfBinding:#{object_id} error: #{e.inspect}\n" + `value.toString()`)
-          current_value = false
+    def update
+      # Find the true branch
+      true_template = nil
+      @branches.each do |branch|
+        value, template_name = branch
+
+        if value.is_a?(Proc)
+          begin
+            current_value = @context.instance_eval(&value)
+          rescue => e
+            Volt.logger.error("IfBinding:#{object_id} error: #{e.inspect}\n" + `value.toString()`)
+            current_value = false
+          end
+        else
+          current_value = value
         end
-      else
-        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
-        break
+        # 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
+          break
+        end
       end
-    end
 
-    # Change out the template only if the true branch has changed.
-    if @last_true_template != true_template
-      @last_true_template = true_template
+      # Change out the template only if the true branch has changed.
+      if @last_true_template != true_template
+        @last_true_template = true_template
 
-      if @template
-        @template.remove
-        @template = nil
-      end
+        if @template
+          @template.remove
+          @template = nil
+        end
 
-      if true_template
-        @template = TemplateRenderer.new(@page, @target, @context, binding_name, true_template)
+        if true_template
+          @template = TemplateRenderer.new(@page, @target, @context, binding_name, true_template)
+        end
       end
     end
-  end
 
-  def remove
-    @computation.stop if @computation
-    @computation = nil
+    def remove
+      @computation.stop if @computation
+      @computation = nil
 
-    @template.remove if @template
+      @template.remove if @template
 
-    super
+      super
+    end
   end
 end

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

@@ -2,35 +2,37 @@
 # 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.
-class GroupedControllers
-  @@controllers = {}
+module Volt
+  class GroupedControllers
+    @@controllers = {}
 
-  def initialize(name)
-    @name = name
-  end
+    def initialize(name)
+      @name = name
+    end
 
-  def get
-    return (controller = self.controller) && controller[0]
-  end
+    def get
+      return (controller = self.controller) && controller[0]
+    end
 
-  def set(controller)
-    @@controllers[@name] = [controller, 1]
-  end
+    def set(controller)
+      @@controllers[@name] = [controller, 1]
+    end
 
-  def inc
-    controller[1] += 1
-  end
+    def inc
+      controller[1] += 1
+    end
 
-  def clear
-    controller = self.controller
-    controller[1] -= 1
-    if controller[1] == 0
-      @@controllers.delete(@name)
+    def clear
+      controller    = self.controller
+      controller[1] -= 1
+      if controller[1] == 0
+        @@controllers.delete(@name)
+      end
     end
-  end
 
-  private
+    private
     def controller
       @@controllers[@name]
     end
-end
+  end
+end