volt 0.3.7 → 0.3.8

data/lib/volt/reactive/object_tracker.rb

@@ -1,4 +1,3 @@
-OBJECT_TRACKER_DEBUG = false
 
 class ObjectTracker
   @@queue = {}
@@ -9,6 +8,15 @@ class ObjectTracker
     @@cache_enabled
   end
   
+  def self.enable_cache
+    clear_cache
+    @@cache_enabled = true
+  end
+  
+  def self.disable_cache
+    @@cache_enabled = false
+  end
+  
   def self.cache_version
     @@cache_version
   end
@@ -18,7 +26,6 @@ class ObjectTracker
   end
   
   def initialize(main_object)
-    # puts "NEW OBJECT TRACKER FOR: #{main_object.inspect}"
     @main_object = main_object
     @enabled = false
   end
@@ -28,41 +35,38 @@ class ObjectTracker
   end
   
   def queue_update
-    puts "QUEUE UPDATE" if OBJECT_TRACKER_DEBUG
     @@queue[self] = true
   end
   
   # Run through the queue and update the followers for each
   def self.process_queue
+    return if @@queue.size == 0
     # puts "PROCESS QUEUE: #{@@queue.size}"
-    puts "Process #{@@queue.size} items" if OBJECT_TRACKER_DEBUG
-    # TODO: Doing a full dup here is expensive?
-    queue = @@queue.dup
+    queue = @@queue
+
+    # puts "Update Followers #{@@queue.size}" 
     
     # Clear before running incase someone adds during
     @@queue = {}
-
-    @@cache_enabled = true
-    self.clear_cache
+    # self.enable_cache
 
     queue.each_pair do |object_tracker,val|
       object_tracker.update_followers
     end
     
-    @@cache_enabled = false
+    # self.disable_cache
     
+    # puts "UPDATED FOLLOWERS"
   end
   
   def enable!
     unless @enabled
-      puts "Enable OBJ Tracker" if OBJECT_TRACKER_DEBUG
       @enabled = true
       queue_update
     end
   end
   
   def disable!
-    puts "Disable OBJ Tracker" if OBJECT_TRACKER_DEBUG
     remove_followers
     @@queue.delete(self)
     @enabled = false
@@ -70,21 +74,22 @@ class ObjectTracker
 
   def update_followers
     if @enabled
-      puts "UPDATE" if OBJECT_TRACKER_DEBUG
       current_obj = @main_object.cur#(true)
       
       # puts "UPDATE ON #{current_obj.inspect}"
-    
-      remove_followers
+      
+      if !@cached_current_obj || current_obj.object_id != @cached_current_obj.object_id
+        remove_followers
   
-      # Add to current
-      should_attach = current_obj.respond_to?(:on)
-      if should_attach
-        current_obj.add_event_follower(@main_object)
-        @cached_current_obj = current_obj
+        # Add to current
+        should_attach = current_obj.respond_to?(:on)
+        if should_attach
+          @cached_current_obj = current_obj
+          # puts "ATTACH: #{@cached_current_obj}"
+          @current_obj_chain_listener = @main_object.event_chain.add_object(@cached_current_obj)
+        end
       end
     else
-      puts "DISABLED, no update" if OBJECT_TRACKER_DEBUG
     end
   end
   
@@ -92,7 +97,9 @@ class ObjectTracker
   def remove_followers
     # Remove from previous
     if @cached_current_obj
-      @cached_current_obj.remove_event_follower(@main_object)
+      @current_obj_chain_listener.remove
+      @current_obj_chain_listener = nil
+      
       @cached_current_obj = nil
     end
   end

data/lib/volt/reactive/reactive_array.rb

@@ -18,7 +18,6 @@ class ReactiveArray# < Array
   end
   
   tag_method(:[]=) do
-    destructive!
     pass_reactive!
   end
   
@@ -69,7 +68,6 @@ class ReactiveArray# < Array
   
 
   tag_method(:<<) do
-    destructive!
     pass_reactive!
   end
   # alias :__old_append :<<
@@ -83,7 +81,7 @@ class ReactiveArray# < Array
     trigger_on_direct_listeners!('added', self.size-1)
     
     trigger_size_change!
-    
+
     return result
   end
   
@@ -172,6 +170,7 @@ class ReactiveArray# < Array
     self.trigger_by_scope!(event_name, *passed_args) do |scope|
       # method_name, *args, block = scope
       method_name, args, block = split_scope(scope)
+      # puts "SCOPE CHECK: TFI: #{method_name.inspect} - #{args.inspect} on #{self.inspect}"
       
       result = case method_name
       when nil

data/lib/volt/reactive/reactive_tags.rb

@@ -1,3 +1,5 @@
+require 'volt/reactive/destructive_methods'
+
 # ReactiveTags provide an easy way to specify how a class deals with 
 # reactive events and method calls.als
 module ReactiveTags
@@ -29,6 +31,11 @@ module ReactiveTags
     
       @reactive_method_tags ||= {}
       @reactive_method_tags[method_name.to_sym] = tagger.method_tags
+      
+      # Track a destructive method
+      if tagger.method_tags.destructive
+        DestructiveMethods.add_method(method_name)
+      end
     end
     
     def tag_all_methods(&block)

data/lib/volt/reactive/reactive_value.rb

@@ -4,6 +4,7 @@ require 'volt/reactive/string_extensions'
 require 'volt/reactive/array_extensions'
 require 'volt/reactive/reactive_array'
 require 'volt/reactive/object_tracker'
+require 'volt/reactive/destructive_methods'
 
 class Object
   def cur
@@ -41,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!].each do |method_name|
+  [:cur, :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
@@ -52,75 +53,53 @@ class ReactiveValue < BasicObject
   end
   alias_method :rm, :reactive_manager  
   
-  def check_tag(method_name, tag_name)
-    current_obj = cur # TODO: should be cached somehow
-    
-    if current_obj.respond_to?(:reactive_method_tag)
-      tag = current_obj.reactive_method_tag(method_name, tag_name)
-      
-      unless tag
-        # Get the tag from the all methods if its not directly specified
-        tag = current_obj.reactive_method_tag(:__all_methods, tag_name)
-      end
-      
-      # Evaluate now if its a proc
-      tag = tag.call(method_name) if tag.class == ::Proc
-      
-      return tag
-    end
-    
-    return nil
-  end
-  
   def puts(*args)
     ::Object.send(:puts, *args)
   end
   
+  def __is_destructive?(method_name)
+    last_char = method_name[-1]
+    if last_char == '=' && method_name[-2] != '='
+      # Method is an assignment (and not a comparator ==)
+      return true
+    elsif last_char == '!' || last_char == '<'
+      # Method is tagged as destructive, or is a push ( << )
+      return true
+    elsif ::DestructiveMethods.might_be_destructive?(method_name)
+      # Method may be destructive, check if it actually is on the current value
+      # TODO: involves a call to cur
+      return reactive_manager.check_tag(method_name, :destructive, self.cur)
+    else
+      return false
+    end
+  end
+  
   def method_missing(method_name, *args, &block)
     # Unroll send into a direct call
     if method_name == :send
       method_name, *args = args
     end
-    
-    # Check to see if the method we're calling wants to receive reactive values.
-    pass_reactive = check_tag(method_name, :pass_reactive)
 
     # For some methods, we pass directly to the current object.  This
     # helps ReactiveValue's be well behaved ruby citizens.
     # Also skip if this is a destructive method
-    if SKIP_METHODS.include?(method_name) || check_tag(method_name, :destructive)# || (method_name[0] =~ /[a-zA-Z]/ && !cur.is_a?(::Exception))
-      pass_args = pass_reactive ? args : args.map{|v| v.cur }
-      return cur.__send__(method_name, *pass_args, &block)
+    if SKIP_METHODS.include?(method_name) || __is_destructive?(method_name)
+      current_obj = self.cur
+      
+      # Unwrap arguments if the method doesn't want reactive values
+      pass_args = reactive_manager.unwrap_if_pass_reactive(args, method_name, current_obj)
+      
+      return current_obj.__send__(method_name, *pass_args, &block)
     end
     
     @block_reactives = []
-    result = @reactive_manager.with_and_options(args, pass_reactive) do |val, in_args|
-      # When a method is called with a block, we pass in our own block that wraps the
-      # block passed in.  This way we can pass in any arguments as reactive and track
-      # the return values.
-      new_block = block
-      # index_cache = []
-      # index = 0
-      # 
-      # if false && new_block
-      #   new_block = ::Proc.new do |*block_args|
-      #     res = block.call(*block_args.map {|v| ::ReactiveValue.new(v) })
-      #     
-      #     result.rm.remove_parent!(index_cache[index]) if index_cache[index]
-      #     puts "index: #{index}"
-      #     index_cache[index] = res
-      # 
-      #     # @block_reactives << res
-      #     result.rm.add_parent!(res)
-      #     # puts "Parent Size: #{result.rm.parents.size}"
-      #     
-      #     index += 1
-      #     
-      #     res.cur
-      #   end
-      # end
-      
-      val.__send__(method_name, *in_args, &new_block)
+    result = @reactive_manager.with_and_options(args) do |val, in_args|
+      # Unwrap arguments if the method doesn't want reactive values
+      # TODO: Should cache the lookup on pass_reactive
+      pass_args = reactive_manager.unwrap_if_pass_reactive(in_args, method_name, val)
+
+      # puts "GET #{method_name.inspect}"
+      val.__send__(method_name, *pass_args, &block)
     end
     
     manager = result.reactive_manager
@@ -209,8 +188,6 @@ class ReactiveManager
     @scope = scope
     
     @parents = []
-    
-    object_tracker.enable!
   end
   
   def reactive?
@@ -226,20 +203,17 @@ class ReactiveManager
   end
   
   
-  # def event_added(event, scope, first)
-  #   # When the first event is registered, we need to start listening on our current object
-  #   # for it to publish events.
-  #   # object_tracker.enable! if first
-  # end
-  # 
-  # def event_removed(event, last)
-  #   # If no one is listening on the reactive value, then we don't need to listen on our
-  #   # current object for events, because no one cares.
-  #   # Note: when we're tracking the current object, it will have one registered changed 
-  #   # event.
-  #   # update_current_object(true) if last && !has_non_tracking_listeners?
-  #   # object_tracker.disable! if @listeners.size == 0
-  # end
+  def event_added(event, scope, first)
+    # When the first event is registered, we need to start listening on our current object
+    # for it to publish events.
+    object_tracker.enable! if first
+  end
+  
+  def event_removed(event, last)
+    # If no one is listening on the reactive value, then we don't need to listen on our
+    # current object for events, because no one cares.
+    object_tracker.disable! if @listeners.size == 0
+  end
   
   def object_tracker
     @object_tracker ||= ::ObjectTracker.new(self)
@@ -248,7 +222,10 @@ class ReactiveManager
 
   # Fetch the current value
   def cur
-    # if @cached_obj && ObjectTracker.cache_version == @cached_version
+    # @@cur_count ||= 0
+    # @@cur_count += 1
+    # puts "Cur: #{@@cur_count}"# if @@cur_count % 100 == 0
+    # if ObjectTracker.cache_version == @cached_version
     #   return @cached_obj
     # end
     
@@ -270,8 +247,8 @@ class ReactiveManager
     end
     
     # if ObjectTracker.cache_enabled
-      # @cached_obj = result
-      # @cached_version = ObjectTracker.cache_version
+    #   @cached_obj = result
+    #   @cached_version = ObjectTracker.cache_version
     # end
     
     return result
@@ -290,14 +267,44 @@ class ReactiveManager
     end
   end
   
+  
+  # Method calls can be tagged so the reactive value knows
+  # how to handle them.  This lets you check the state of
+  # the tags.
+  def check_tag(method_name, tag_name, current_obj)
+    if current_obj.respond_to?(:reactive_method_tag)
+      tag = current_obj.reactive_method_tag(method_name, tag_name)
+      
+      unless tag
+        # Get the tag from the all methods if its not directly specified
+        tag = current_obj.reactive_method_tag(:__all_methods, tag_name)
+      end
+      
+      # Evaluate now if its a proc
+      tag = tag.call(method_name) if tag.class == ::Proc
+      
+      return tag
+    end
+    
+    return nil
+  end
+  
+  def unwrap_if_pass_reactive(args, method_name, current_obj)
+    # Check to see if the method we're calling wants to receive reactive values.
+    pass_reactive = check_tag(method_name, :pass_reactive, current_obj)
+
+    # Unwrap arguments if the method doesn't want reactive values
+    return pass_reactive ? args : args.map{|v| v.cur }
+  end
+  
   # With returns a new reactive value dependent on any arguments passed in.
   # If a block is passed in, the getter is the block its self, which will
   # be passed the .cur and the .cur of any reactive arguments.
   def with(*args, &block)
-    return with_and_options(args, false, &block)
+    return with_and_options(args, &block)
   end
   
-  def with_and_options(args, pass_reactive, &block)
+  def with_and_options(args, &block)
     getter = @getter
     setter = @setter
     scope = @scope
@@ -305,17 +312,14 @@ class ReactiveManager
     if block
       # If a block was passed in, the getter now becomes a proc that calls
       # the passed in block with the right arguments.
-      getter = ::Proc.new do
-        # Unwrap arguments if the method doesn't want reactive values
-        pass_args = pass_reactive ? args : args.map{|v| v.cur }
-        
+      getter = ::Proc.new do        
         # TODO: Calling cur every time
         current_val = self.cur
         
         if current_val.is_a?(Exception)
           current_val
         else
-          block.call(current_val, pass_args)
+          block.call(current_val, args)
         end
       end
       
@@ -331,7 +335,7 @@ class ReactiveManager
     
     # Add the ReactiveValue we're building from
     new_val.reactive_manager.add_parent!(self)
-    
+
     # Add any reactive arguments as parents
     args.select(&:reactive?).each do |arg|
       new_val.reactive_manager.add_parent!(arg.reactive_manager)
@@ -349,6 +353,7 @@ class ReactiveManager
     @parents.delete(parent)
     event_chain.remove_object(parent)
   end
+
   
   def set_scope!(new_scope)
     @scope = new_scope

data/lib/volt/reactive/string_extensions.rb

@@ -19,9 +19,6 @@ class String
   end
 
   if RUBY_PLATFORM != 'opal'
-    tag_method(:<<) do
-      destructive!
-    end
     def <<(val)
       if val.reactive?
         raise "Cannot append a reactive string to non-reactive string.  Use + instead"

data/lib/volt/router/routes.rb

@@ -63,9 +63,9 @@ class Routes
     match_path = ''
     sections.each do |section|
       if section[0] == '{' && section[-1] == '}'
-        match_path << "[^\/]+"
+        match_path = match_path + "[^\/]+"
       else
-        match_path << section
+        match_path = match_path + section
       end
     end
     

data/lib/volt/server/channel_handler.rb

@@ -2,9 +2,19 @@ require 'json'
 require 'sockjs/session'
 
 class ChannelHandler < SockJS::Session
-  def self.message_all(message)
+  # Create one instance of the dispatcher
+  
+  def self.dispatcher=(val)
+    @@dispatcher = val
+  end
+  
+  # Sends a message to all, optionally skipping a users channel
+  def self.send_message_all(skip_channel=nil, *args)
     @@channels.each do |channel|
-      channel.send(message)
+      if skip_channel && channel == skip_channel
+        next
+      end
+      channel.send_message(*args)
     end
     
   end
@@ -19,8 +29,18 @@ class ChannelHandler < SockJS::Session
   end
   
   def process_message(message)
-    puts "Process: #{message}"
-    self.class.message_all(message)
+    # self.class.message_all(message)
+    # Messages are json and wrapped in an array
+    message = JSON.parse(message).first
+    
+    puts "GOT: #{message.inspect}"
+    @@dispatcher.dispatch(self, message)
+  end
+  
+  def send_message(*args)
+    str = JSON.dump([*args])
+    
+    send(str)
   end
   
   def closed    

data/lib/volt/server/component_handler.rb

@@ -16,8 +16,9 @@ class ComponentHandler
     component_name = req.path.strip.gsub(/^\/components\//, '').gsub(/[.]js$/, '')
 
     code = ''
+    
 
-    component_files = ComponentFiles.new(component_name, @component_paths)
+    component_files = ComponentFiles.new(component_name, @component_paths, true)
     component_files.component_paths.each do |component_path, component_name|
       code << ComponentTemplates.new(component_path, component_name).code
       code << "\n\n"

data/lib/volt/server/rack/component_files.rb

@@ -12,6 +12,7 @@ class ComponentFiles
     @main_component = main_component
     
     if @main_component
+      # puts "ADD VOLT"
       # Add in volt's JS files first
       component('volt')
     end
@@ -89,9 +90,9 @@ class ComponentFiles
     
     opal_js_files = []
     if Volt.source_maps?
-      opal_js_files += opal_files.environment['volt/templates/page'].to_a.map {|v| '/assets/' + v.logical_path + '?body=1' }
+      opal_js_files += opal_files.environment['volt/page/page'].to_a.map {|v| '/assets/' + v.logical_path + '?body=1' }
     else
-      opal_js_files << '/assets/volt/templates/page.js'
+      opal_js_files << '/assets/volt/page/page.js'
     end
     opal_js_files << '/components/home.js'
 

data/lib/volt/server/rack/component_paths.rb

@@ -37,7 +37,7 @@ class ComponentPaths
           folder_name = folder[/[^\/]+$/]
           
           @components[folder_name] ||= []
-          @components[folder_name] << folder
+          @components[folder_name] << folder          
         end
       end
     end
@@ -45,6 +45,16 @@ class ComponentPaths
     return @components
   end
   
+  def add_tasks_to_load_path
+    components.each do |name,component_folders|
+      component_folders.each do |component_folder|
+        Dir["#{component_folder}/tasks"].each do |tasks_folder|
+          $LOAD_PATH.unshift(tasks_folder)
+        end
+      end
+    end
+  end
+  
   def component_path(name)
     folders = components[name]
     

data/lib/volt/server/rack/index_files.rb

@@ -44,7 +44,7 @@ class IndexFiles
   end
   
   def css_files
-    ComponentFiles.new('home', @component_paths).css_files
+    ComponentFiles.new('home', @component_paths, true).css_files
   end
 
   

data/lib/volt/server.rb

@@ -6,6 +6,7 @@ if RUBY_PLATFORM != 'java'
 end
 require "sprockets-sass"
 require "sass"
+require 'listen'
 
 require 'volt/extra_core/extra_core'
 require 'volt/server/component_handler'
@@ -15,12 +16,24 @@ end
 require 'volt/server/rack/component_paths'
 require 'volt/server/rack/index_files'
 require 'volt/server/rack/opal_files'
+require 'volt/tasks/dispatcher'
 
 
 class Server
   def initialize
     @app_path = File.expand_path(File.join(Dir.pwd, "app"))
     @component_paths = ComponentPaths.new
+    
+    setup_change_listener
+  end
+  
+  def setup_change_listener
+    # Setup the listeners for file changes
+    puts "Listen for changes at #{@app_path}"
+    listener = Listen.to("#{@app_path}/") do |modified, added, removed|
+      ChannelHandler.send_message_all(nil, 'reload')
+    end
+    listener.start
   end
   
   def app
@@ -42,6 +55,9 @@ class Server
     
     # Handle socks js connection
     if RUBY_PLATFORM != 'java'
+      component_paths.add_tasks_to_load_path
+      ChannelHandler.dispatcher = Dispatcher.new
+      
       @app.map "/channel" do
         run Rack::SockJS.new(ChannelHandler)#, :websocket => false
       end

data/lib/volt/store/mongo.rb

@@ -2,4 +2,4 @@ require 'mongo'
 
 mongo_client = Mongo::MongoClient.new("localhost", 27017)
 
-db = mongo_client.db("test1")
+db = mongo_client.db("test1")

data/lib/volt/tasks/dispatcher.rb

@@ -0,0 +1,25 @@
+# The task dispatcher is responsible for taking incoming messages
+# from the socket channel and dispatching them to the proper handler.
+class Dispatcher
+  
+  def dispatch(channel, message)
+    callback_id, class_name, method_name, *args = message
+
+    # TODO: Think about security?
+    
+    if class_name[/Tasks$/] && !class_name['::']
+      require(class_name.underscore)
+      
+      # Get the class
+      klass = Object.send(:const_get, class_name)
+      
+      # Init and send the method
+      result = klass.new(channel, self).send(method_name, *args)
+      
+      if callback_id
+        # Callback with result
+        channel.send_message('response', callback_id, result)
+      end
+    end
+  end
+end