volt 0.5.18 → 0.6.0

data/lib/volt/page/template_renderer.rb

@@ -2,12 +2,12 @@ require 'volt/page/bindings/base_binding'
 
 class TemplateRenderer < BaseBinding
   attr_reader :context
-  def initialize(target, context, binding_name, template_name)
+  def initialize(page, target, context, binding_name, template_name)
     # puts "new template renderer: #{context.inspect} - #{binding_name.inspect}"
-    super(target, context, binding_name)
+    super(page, target, context, binding_name)
 
     # puts "Template Name: #{template_name}"
-    @template = $page.templates[template_name]
+    @template = @page.templates[template_name]
     @sub_bindings = []
 
     if @template
@@ -22,7 +22,7 @@ class TemplateRenderer < BaseBinding
 
     bindings.each_pair do |id,bindings_for_id|
       bindings_for_id.each do |binding|
-        @sub_bindings << binding.call(target, context, id)
+        @sub_bindings << binding.call(page, target, context, id)
       end
     end
   end

data/lib/volt/reactive/events.rb

@@ -201,5 +201,19 @@ module Events
   def trigger_by_scope!(event, *args, &block)
     trigger!(event, block, *args)
   end
+  
+  # Takes an event and a list of method names, and triggers the event for each listener
+  # coming off of those methods.
+  def trigger_for_methods!(event, *method_names)
+    trigger_by_scope!(event, [], nil) do |scope|
+      if scope
+        method_name = scope.first
+      
+        method_names.include?(method_name)
+      else
+        false
+      end
+    end
+  end
 
 end

data/lib/volt/reactive/reactive_array.rb

@@ -87,6 +87,14 @@ class ReactiveArray# < Array
     self.delete_at(@array.index(val))
   end
   
+  # Removes all items in the array model.
+  tag_method(:clear) do
+    destructive!
+  end
+  def clear
+    @array = []
+    trigger!('changed')
+  end
 
   tag_method(:<<) do
     pass_reactive!
@@ -126,14 +134,16 @@ class ReactiveArray# < Array
   tag_method(:insert) do
     destructive!
   end
-  # alias :__old_insert :insert
-  def insert(*args)
-    old_size = self.size
-    result = @array.insert(*args)
+  def insert(index, *objects)
+    result = @array.insert(index, *objects)
 
-    old_size.upto(result.size-1) do |index|
-      trigger_for_index!('changed', index)
-      trigger_on_direct_listeners!('added', old_size+index)
+    # All objects from index to the end have "changed"
+    index.upto(result.size-1) do |idx|
+      trigger_for_index!('changed', idx)
+    end
+
+    objects.size.times do |count|
+      trigger_on_direct_listeners!('added', index+count)
     end
     
     trigger_size_change!

data/lib/volt/reactive/reactive_value.rb

@@ -42,7 +42,7 @@ class ReactiveValue < BasicObject
   # Proxy methods to the ReactiveManager.  We want to have as few
   # as possible methods on reactive values, so all other methods
   # are forwarded to the object the reactive value points to.
-  [:cur, :cur=, :on, :trigger!, :trigger_by_scope!].each do |method_name|
+  [:cur, :cur=, :deep_cur, :on, :trigger!, :trigger_by_scope!].each do |method_name|
     define_method(method_name) do |*args, &block|
       @reactive_manager.send(method_name, *args, &block)
     end
@@ -173,6 +173,63 @@ class ReactiveValue < BasicObject
       return [wrapped_object, self]
     end
   end
+  
+  # Return a new reactive value that listens for changes on any
+  # ReactiveValues inside of its children (hash values, array items, etc..)
+  # This is useful if someone is passing in a set of options, but the main
+  # hash isn't a ReactiveValue, but you want to listen for changes inside
+  # of the hash.
+  #
+  # skip_if_no_reactives lets you get back a non-reactive value in the event
+  #    that there are no child reactive values.
+  def self.from_hash(hash, skip_if_no_reactives=false)
+    ::ReactiveGenerator.from_hash(hash)
+  end
+end
+
+class ReactiveGenerator
+  # Takes a hash and returns a ReactiveValue that depends on
+  # any ReactiveValue's inside of the hash (or children).
+  def self.from_hash(hash, skip_if_no_reactives=false)
+    reactives = find_reactives(hash)
+    
+    if skip_if_no_reactives && reactives.size == 0
+      # There weren't any reactives, we can just use the hash
+      return hash
+    else
+      # Create a new reactive value that listens on all of its
+      # child reactive values.
+      value = ReactiveValue.new(hash)
+    
+      reactives.each do |child|
+        value.reactive_manager.add_parent!(child)
+      end
+    
+      return value
+    end
+  end
+
+  # Recursively loop through the data, returning a list of all
+  # reactive values in the hash, array, etc..
+  def self.find_reactives(object)
+    found = []
+    if object.reactive?
+      found << object
+      
+      found += find_reactives(object.cur)
+    elsif object.is_a?(Array)
+      object.each do |item|
+        found += find_reactives(item)
+      end
+    elsif object.is_a?(Hash)
+      object.each_pair do |key, value|
+        found += find_reactives(key)
+        found += find_reactives(value)
+      end
+    end
+    
+    return found.flatten
+  end
 end
 
 class ReactiveManager
@@ -266,6 +323,13 @@ class ReactiveManager
     end
   end
   
+  # Returns a copy of the object with where all ReactiveValue's are replaced
+  # with their current value.
+  # NOTE: Classes need to implement their own deep_cur method for this to work,
+  # it works out of the box with arrays and hashes.
+  def deep_cur
+    self.cur.deep_cur
+  end
   
   # Method calls can be tagged so the reactive value knows
   # how to handle them.  This lets you check the state of

data/lib/volt/server.rb

@@ -10,7 +10,7 @@ require "sass"
 require "sprockets-sass"
 require 'listen'
 
-require 'volt/extra_core/extra_core'
+require 'volt'
 require 'volt/server/component_handler'
 if RUBY_PLATFORM != 'java'
   require 'volt/server/socket_connection_handler'

data/lib/volt/server/if_binding_setup.rb

@@ -24,6 +24,8 @@ class IfBindingSetup < BindingSetup
       "[#{content}, #{branch[1].inspect}]"
     end.join(', ')
     
-    "lambda { |target, context, id| IfBinding.new(target, context, id, [#{branches}]) }"
+    # variables are captured for branches, so we must prefix them so they don't conflict.
+    # page, target, context, id
+    "lambda { |__p, __t, __c, __id| IfBinding.new(__p, __t, __c, __id, [#{branches}]) }"
   end
 end

data/lib/volt/server/socket_connection_handler.rb

@@ -37,7 +37,6 @@ class SocketConnectionHandler < SockJS::Session
     # Messages are json and wrapped in an array
     message = JSON.parse(message).first
     
-    puts "GOT: #{message.inspect}"
     @@dispatcher.dispatch(self, message)
   end
   
@@ -48,12 +47,15 @@ class SocketConnectionHandler < SockJS::Session
   end
   
   def closed
-    puts "CHANNEL CLOSED"
+    puts "CHANNEL CLOSED: #{self.inspect}"
     # Remove ourself from the available channels
     @@channels.delete(self)
-    
-    # Remove any listening channels
-    ChannelTasks.new(self).close!
+
+    QueryTasks.new(self).close!
+  end
+  
+  def inspect
+    "<#{self.class.to_s}:#{object_id}>"
   end
 
 end

data/lib/volt/server/template_parser.rb

@@ -72,7 +72,7 @@ class Template
 	def add_template(node, content, name='Template')
 		html = "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
 
-		@current_scope.add_binding(@binding_number, "lambda { |target, context, id| #{name}Binding.new(target, context, id, #{@template_parser.template_path.inspect}, Proc.new { [#{content}] }) }")
+		@current_scope.add_binding(@binding_number, "lambda { |__p, __t, __c, __id| #{name}Binding.new(__p, __t, __c, __id, #{@template_parser.template_path.inspect}, Proc.new { [#{content}] }) }")
 
 		@binding_number += 1
 		return html
@@ -84,7 +84,7 @@ class Template
     content, variable_name = content.strip.split(/ as /)
 
     template_name = "#{@template_parser.template_path}/#{section_name}/__template/#{@binding_number}"
-		@current_scope.add_binding(@binding_number, "lambda { |target, context, id| EachBinding.new(target, context, id, Proc.new { #{content} }, #{variable_name.inspect}, #{template_name.inspect}) }")
+		@current_scope.add_binding(@binding_number, "lambda { |__p, __t, __c, __id| EachBinding.new(__p, __t, __c, __id, Proc.new { #{content} }, #{variable_name.inspect}, #{template_name.inspect}) }")
 
 		# Add the node, the binding number, then store the location where the
 		# bindings for this block starts.
@@ -151,7 +151,7 @@ class Template
 	def add_text_binding(content)
 		html = "<!-- $#{@binding_number} --><!-- $/#{@binding_number} -->"
 
-		@current_scope.add_binding(@binding_number, "lambda { |target, context, id| ContentBinding.new(target, context, id, Proc.new { #{content} }) }")
+		@current_scope.add_binding(@binding_number, "lambda { |__p, __t, __c, __id| ContentBinding.new(__p, __t, __c, __id, Proc.new { #{content} }) }")
 
 		@binding_number += 1
 		return html
@@ -194,7 +194,7 @@ class Template
       getter = "_tmp = #{content[1..-2]}.or('') ; _tmp.reactive_manager.setter! { |val| self.#{content[1..-2]} = val } ; _tmp"
     end
     
-    @current_scope.add_binding(node['id'], "lambda { |target, context, id| AttributeBinding.new(target, context, id, #{attribute.inspect}, Proc.new { #{getter} }) }")
+    @current_scope.add_binding(node['id'], "lambda { |__p, __t, __c, __id| AttributeBinding.new(__p, __t, __c, __id, #{attribute.inspect}, Proc.new { #{getter} }) }")
   end
   
   def add_multiple_getters(node, attribute, content)
@@ -208,7 +208,7 @@ class Template
     
     reactive_template_path = add_reactive_template(content)
     
-    @current_scope.add_binding(node['id'], "lambda { |target, context, id| AttributeBinding.new(target, context, id, #{attribute.inspect}, Proc.new { ReactiveTemplate.new(context, #{reactive_template_path.inspect}) }) }")
+    @current_scope.add_binding(node['id'], "lambda { |__p, __t, __c, __id| AttributeBinding.new(__p, __t, __c, __id, #{attribute.inspect}, Proc.new { ReactiveTemplate.new(__p, __c, #{reactive_template_path.inspect}) }) }")
   end
   
   # Returns a path to a template for the content.  This can be passed
@@ -237,7 +237,7 @@ class Template
       node['href'] ||= ''
     end
 
-    @current_scope.add_binding(node['id'], "lambda { |target, context, id| EventBinding.new(target, context, id, #{event.inspect}, Proc.new {|event| #{content} })}")
+    @current_scope.add_binding(node['id'], "lambda { |__p, __t, __c, __id| EventBinding.new(__p, __t, __c, __id, #{event.inspect}, Proc.new {|event| #{content} })}")
   end
 
 	def pull_closed_block_scopes(scope=@current_scope)
@@ -337,7 +337,7 @@ class Template
         # Has multiple bindings, we need to render a template here
         attr_template_path = add_reactive_template(content)
         
-        value = "Proc.new { ReactiveTemplate.new(context, #{attr_template_path.inspect}) }"
+        value = "Proc.new { ReactiveTemplate.new(__p, __c, #{attr_template_path.inspect}) }"
       end
       
       attribute_hash[attribute_node.name] = value

data/lib/volt/tasks/dispatcher.rb

@@ -18,6 +18,9 @@ class Dispatcher
         result = klass.new(channel, self).send(method_name, *args)
         error = nil
       rescue => e
+        # TODO: Log these errors better
+        puts "ERROR: #{e.inspect}"
+        puts e.backtrace
         result = nil
         error = e
       end

data/lib/volt/utils/ejson.rb

@@ -0,0 +1,9 @@
+class EJson
+  def self.dump_as(obj)
+    obj
+  end
+  
+  def self.dump(obj)
+    JSON.dump(dump_as(obj))
+  end
+end

data/lib/volt/utils/generic_counting_pool.rb

@@ -0,0 +1,44 @@
+require 'volt/utils/generic_pool'
+
+# A counting pool behaves like a normal GenericPool, except for
+# each time lookup is called, remove should be called when complete.
+# The item will be completely removed from the GenericCountingPool 
+# only when it has been removed an equal number of times it has been
+# looked up.
+class GenericCountingPool < GenericPool
+  # return a created item with a count
+  def generate_new(*args)
+    [0, create(*args)]
+  end
+  
+  # Finds an item and tracks that it was checked out.  Use
+  # #remove when the item is no longer needed.
+  def find(*args, &block)
+    item = __lookup(*args, &block)
+    
+    item[0] += 1
+    
+    return item[1]
+  end
+
+  # Lookups an item
+  def lookup(*args, &block)
+    item = super(*args, &block)
+    
+    return item[1]
+  end
+  
+  def transform_item(item)
+    [0, item]
+  end
+  
+  def remove(*args)
+    item = __lookup(*args)
+    item[0] -= 1
+    
+    if item[0] == 0
+      # Last one using this item has removed it.
+      super(*args)
+    end
+  end
+end

data/lib/volt/utils/generic_pool.rb

@@ -0,0 +1,88 @@
+# GenericPool is a base class you can inherit from to cache items
+# based on a lookup.
+#
+# GenericPool assumes either a block is passed to lookup, or a
+# #create method, that takes the path arguments and reutrns a new instance.
+#
+# GenericPool can handle as deep of paths as needed.  You can also lookup
+# all of the items at a sub-path with #lookup_all
+#
+# TODO: make the lookup/create threadsafe
+class GenericPool
+  attr_reader :pool
+  def initialize
+    @pool = {}
+  end
+  
+  def lookup(*args, &block)
+    section = @pool
+    
+    # TODO: This is to work around opal issue #500
+    if RUBY_PLATFORM == 'opal'
+      args.pop if args.last == nil
+    end
+    
+    
+    args.each_with_index do |arg, index|
+      last = (args.size-1) == index
+      
+      if last
+        # return, creating if needed
+        return(section[arg] ||= create_new_item(*args, &block))
+      else
+        next_section = section[arg]
+        next_section ||= (section[arg] = {})
+        section = next_section
+      end
+    end
+  end
+  
+  # Does the actual creating, if a block is not passed in, it calls
+  # #create on the class.
+  def create_new_item(*args)
+    if block_given?
+      new_item = yield(*args)
+    else
+      new_item = create(*args)
+    end
+    
+    return transform_item(new_item)
+  end
+  
+  # Allow other pools to override how the created item gets stored.
+  def transform_item(item)
+    item
+  end
+  
+  # Make sure we call the pool one from lookup_all and not
+  # an overridden one.
+  alias_method :__lookup, :lookup
+  
+  def lookup_all(*args)
+    __lookup(*args).values
+  end
+  
+  def remove(*args)
+    stack = []
+    section = @pool
+    
+    args.each_with_index do |arg, index|      
+      stack << section
+
+      if args.size-1 == index
+        section.delete(arg)
+      else
+        section = section[arg]
+      end
+    end
+    
+    (stack.size-1).downto(1) do |index|
+      node = stack[index]
+      parent = stack[index-1]
+      
+      if node.size == 0
+        parent.delete(args[index-1])
+      end
+    end
+  end
+end

data/spec/models/reactive_array_spec.rb

@@ -17,6 +17,49 @@ describe ReactiveArray do
     expect(@changed).to eq(true)
   end
   
+  it "should trigger changed from an insert in all places after the index" do
+    model = ReactiveValue.new(Model.new)
+    model._my_ary = [1,2,3]
+    
+    count1 = 0
+    count2 = 0
+    model._my_ary[1].on('changed') { count1 += 1 }
+    model._my_ary[3].on('changed') { count2 += 1 }
+    expect(count1).to eq(0)
+    expect(count2).to eq(0)
+    
+    model._my_ary.insert(1, 10)
+    expect(count1).to eq(1)
+    expect(count2).to eq(1)
+    
+    expect(model._my_ary.cur).to eq([1,10,2,3])
+  end
+  
+  it "should pass the index the item was inserted at" do
+    model = ReactiveValue.new(Model.new)
+    model._my_ary = [1,2,3]
+    
+    model._my_ary.on('added') do |_, index|
+      expect(index).to eq(2)
+    end
+    
+    model._my_ary.insert(2, 20)
+  end
+  
+  it "should pass the index the item was inserted at with multiple inserted objects" do
+    model = ReactiveValue.new(Model.new)
+    model._my_ary = [1,2,3]
+    
+    received = []
+    model._my_ary.on('added') do |_, index|
+      received << index
+    end
+    
+    model._my_ary.insert(2, 20, 30)
+    
+    expect(received).to eq([2, 3])
+  end
+  
   it "should trigger changed on methods of an array model that involve just one cell" do
     model = ReactiveValue.new(ReactiveArray.new)