volt 0.2.3

data/lib/volt/models/params.rb

@@ -0,0 +1,67 @@
+# All url related data is stored in params.  This includes the main uri
+# in addition to any query parameters.  The router is responsible for
+# converting any uri sections into params.  Sections in the uri will
+# override any specified parameters.
+#
+# The params value can be updated the same way a model would be, only
+# the updates will trigger an updated url via the browser history api.
+# TODO: Support # for browsers without the history api.
+
+class Params < Model    
+  def initialize(*args)
+    super(*args)
+  end
+  
+  def deep_clone
+    new_obj = clone
+    
+    new_obj.attributes = new_obj.attributes.dup
+    
+    new_obj
+  end
+
+  tag_method(:delete) do
+    destructive!
+  end
+  def delete(*args)
+    super
+    
+    value_updated
+  end
+
+  def method_missing(method_name, *args, &block)
+    result = super
+    
+    if method_name[0] == '_' && method_name[-1] == '='
+      # Trigger value updated after an assignment
+      self.value_updated
+    end
+    
+    return result
+  end
+  
+  def value_updated
+    # Once the initial url has been parsed and set into the attributes,
+    # start triggering updates on change events.
+    # TODO: This is a temp solution, we need to make it so value_updated
+    # is called after the reactive_value has been updated.
+    if RUBY_PLATFORM == 'opal'
+      %x{
+        if (window.setTimeout && this.$run_update.bind) {
+          if (window.paramsUpdateTimer) {
+            clearTimeout(window.paramsUpdateTimer);
+          }
+          window.paramsUpdateTimer = setTimeout(this.$run_update.bind(this), 0);
+        }
+      }
+    end
+  end
+  
+  def run_update
+    $page.params.trigger!('child_changed') if Volt.client?
+  end
+  
+  def new_model(*args)
+    Params.new(*args)
+  end
+end

data/lib/volt/models/url.rb

@@ -0,0 +1,192 @@
+# The url class handles parsing and updating the url
+class URL
+  include ReactiveTags
+  
+  # TODO: we need to make it so change events only trigger on changes
+  attr_reader :scheme, :host, :port, :path, :query, :params
+  attr_accessor :router
+  
+  def initialize(router=nil)
+    @router = router
+    @params = Params.new({}, 'params')
+  end
+  
+  # Parse takes in a url and extracts each sections.
+  # It also assigns and changes to the params.
+  tag_method(:parse) do
+    destructive!
+  end
+  def parse(url)
+    matcher = url.match(/^(https?)[:]\/\/([^\/]+)(.*)$/)
+    @scheme = matcher[1]
+    @host, @port = matcher[2].split(':')
+    @port ||= 80
+    
+    @path = matcher[3]
+    @path, @fragment = @path.split('#', 2)
+    @path, @query = @path.split('?', 2)
+
+    assign_query_hash_to_params
+  end
+
+  # Full url rebuilds the url from it's constituent parts
+  def full_url
+    if @port
+      host_with_port = "#{@host}:#{@port}"
+    else
+      host_with_port = @host
+    end
+    
+    path, params = @router.url_for_params(@params)
+
+    new_url = "#{@scheme}://#{host_with_port}#{path || @path}"
+    
+    unless params.empty?
+      new_url += '?'
+      query_parts = []
+      nested_params_hash(params).each_pair do |key,value|
+        value = value.cur
+        # remove the _ from the front
+        value = `encodeURI(value)`
+        query_parts << "#{key}=#{value}"
+      end
+      
+      new_url += query_parts.join('&')
+    end
+    
+    return new_url
+  end
+  
+  # Called when the state has changed and the url in the
+  # browser should be updated
+  # Called when an attribute changes to update the url
+  tag_method(:update!) do
+    destructive!
+    # TODO: ! methods should default to destructive
+  end
+  def update!
+    new_url = full_url()
+    
+    if `(document.location.href != new_url)`
+      `history.pushState(null, null, new_url)`
+    end
+  end
+  
+  private
+    # Assigning the params is tricky since we don't want to trigger changed on
+    # any values that have not changed.  So we first loop through all current
+    # url params, removing any not present in the params, while also removing
+    # them from the list of new params as added.  Then we loop through the 
+    # remaining new parameters and assign them.
+    def assign_query_hash_to_params
+      # Get a nested hash representing the current url params.
+      query_hash = self.query_hash
+      
+      # Get the params that are in the route
+      query_hash.merge!(@router.params_for_path(@path))
+      
+      # Loop through the .params we already have assigned.
+      assign_from_old(@params, query_hash)
+      assign_new(@params, query_hash)
+    end
+    
+    def assign_from_old(params, new_params)
+      queued_deletes = []
+      
+      params.cur.attributes.each_pair do |name,old_val|
+        # If there is a new value, see if it has [name]
+        new_val = new_params ? new_params[name] : nil
+        
+        if !new_val
+          # Queues the delete until after we finish the each_pair loop
+          queued_deletes << name
+        elsif new_val.is_a?(Hash)
+          assign_from_old(old_val, new_val)
+        else
+          # assign value
+          if old_val != new_val
+            params.send(:"#{name}=", new_val)
+          end
+          new_params.delete(name)
+        end
+      end
+      
+      queued_deletes.each {|name| params.delete(name) }
+    end
+    
+    def assign_new(params, new_params)
+      new_params.each_pair do |name, value|
+        if value.is_a?(Hash)
+          assign_new(params.send(name), value)
+        else
+          # assign
+          params.send(:"#{name}=", value)
+        end
+      end
+    end
+    
+    def query_hash
+      query_hash = {}
+      if @query
+        @query.split('&').reject {|v| v == '' }.each do |part|
+          parts = part.split('=').reject {|v| v == '' }
+      
+          # Decode string
+          # parts[0] = `decodeURI(parts[0])`
+          parts[1] = `decodeURI(parts[1])`
+        
+          sections = query_key_sections(parts[0])
+        
+          hash_part = query_hash
+          sections.each_with_index do |section,index|
+            if index == sections.size-1
+              # Last part, assign the value
+              hash_part[section] = parts[1]
+            else
+              hash_part = (hash_part[section] ||= {})
+            end
+          end
+        end
+      end
+      
+      return query_hash
+    end
+    
+    # Splits a key from a ?key=value&... parameter into its nested 
+    # parts.  It also adds back the _'s used to access them in params.
+    # Example:
+    # user[name]=Ryan would parse as [:_user, :_name]
+    def query_key_sections(key)
+      key.split(/\[([^\]]+)\]/).reject(&:empty?).map {|v| :"_#{v}"}
+    end
+    
+    # Generate the key for a nested param attribute
+    def query_key(path)
+      i = 0
+      path.map do |v|
+        v = v[1..-1]
+        i += 1
+        if i != 1
+          "[#{v}]"
+        else
+          v
+        end
+      end.join('')
+    end
+  
+    def nested_params_hash(params, path=[])
+      results = {}
+    
+      params.each_pair do |key,value|
+        if value.cur.is_a?(Params) # TODO: Should be a param
+          # TODO: Broke here somehow for nested
+          results.merge!(nested_params_hash(value, path + [key]))
+        else
+          results[query_key(path + [key])] = value
+        end
+      end
+    
+      return results
+    end
+  
+end

data/lib/volt/page/url_tracker.rb

@@ -0,0 +1,36 @@
+# The URLTracker is responsible for updating the url when
+# a param changes, or updating the url model/params when
+# the browser url changes.
+class UrlTracker
+  def initialize(page)
+    @page = page
+    
+    if Volt.client?
+      page.params.on('child_changed') do
+        @page.url.update!
+      end
+
+      that = self
+      
+      # Setup popstate on the dom ready event.  Prevents an extra
+      # popstate trigger
+      %x{
+        var first = true;
+        window.addEventListener("popstate", function(e) {
+          if (first === false) {
+            that.$url_updated();
+          }
+          
+          first = false;
+        
+          return true;
+        });
+      }
+    end
+  end
+  
+  def url_updated(first_call=false)
+    @page.url.parse(`document.location.href`)
+    @page.url.update! unless first_call
+  end
+end

data/lib/volt/reactive/array_extensions.rb

@@ -0,0 +1,13 @@
+class Array
+  include ReactiveTags
+  alias :__old_plus :+
+
+  def +(val)
+    result = __old_plus(val.cur)
+    if val.reactive? && !result.reactive?
+      result = ReactiveValue.new(result)
+    end
+  
+    return result
+  end
+end

data/lib/volt/reactive/event_chain.rb

@@ -0,0 +1,126 @@
+CHAIN_DEBUG = false
+
+class ChainListener
+  attr_reader :object, :callback
+  
+  def initialize(event_chain, object, callback)
+    @event_chain = event_chain
+    @object = object
+    @callback = callback
+    
+    if RUBY_PLATFORM == 'opal' && CHAIN_DEBUG
+      `window.chain_listeners = window.chain_listeners || 0;`
+      `window.chain_listeners += 1;`
+      `console.log('chain listeners: ', window.chain_listeners)`
+    end
+  end
+  
+  def remove
+    raise "event chain already removed" if @removed
+    @removed = true
+    @event_chain.remove_object(self)
+    
+    # We need to clear these to free memory
+    @event_chain = nil
+    @object = nil
+    @callback = nil
+    
+    if RUBY_PLATFORM == 'opal' && CHAIN_DEBUG
+      `window.chain_listeners -= 1;`
+    end
+  end
+end
+
+class EventChain
+  def initialize(main_object)
+    @event_chain = {}
+    @main_object = main_object
+    @event_counts = {}
+  end
+  
+  # Register an event listener that chains from object to self
+  def setup_listener(event, chain_listener)
+    return chain_listener.object.on(event, @main_object) do |*args|
+      if callback = chain_listener.callback
+        callback.call(event, *args)
+      else
+        # Trigger on this value, when it happens on the parent
+        @main_object.trigger!(event, *args)
+      end
+    end
+  end
+  
+  def all_listening_events
+    all_listeners = []
+    all_listeners += @main_object.listeners.keys
+    
+    if @main_object
+      @main_object.event_followers.each do |event_follower|
+        all_listeners += event_follower.listeners.keys
+      end
+    end
+    
+    return all_listeners.uniq
+  end
+
+  
+  # We can chain our events to any other object that includes
+  # Events
+  def add_object(object, &block) 
+    # puts "ADD OBJECT: #{object.inspect} to #{self.inspect}" 
+      
+    chain_listener = ChainListener.new(self, object, block)
+
+    listeners = {}
+    
+    all_listening_events.uniq.each do |event|
+      # Create a listener for each event
+      listeners[event] = setup_listener(event, chain_listener)
+    end
+    
+    @event_chain[chain_listener] = listeners
+    
+    return chain_listener
+  end
+  
+  
+  def remove_object(chain_listener)
+    @event_chain[chain_listener].each_pair do |event,listener|
+      # Unbind each listener
+      listener.remove
+    end
+    
+    @event_chain.delete(chain_listener)
+  end
+  
+  def add_event(event)
+    unless @event_counts[event]
+      @event_chain.each_pair do |chain_listener,listeners|
+        # Only add if we haven't already chained this event  
+        unless listeners[event]
+          listeners[event] = setup_listener(event, chain_listener)
+        end
+      end
+    end
+    
+    @event_counts[event] ||= 0
+    @event_counts[event] += 1
+  end
+  
+  # Removes the event from all events in all objects
+  def remove_event(event)
+    if @event_counts[event]
+      count = @event_counts[event] -= 1
+      
+      if count == 0
+        @event_chain.each_pair do |chain_listener,listeners|
+          listeners[event].remove# if listeners[event]
+          listeners.delete(event)
+        end
+        
+        # Also remove the event count
+        @event_counts.delete(event)
+      end
+    end
+  end
+end

data/lib/volt/reactive/events.rb

@@ -0,0 +1,283 @@
+require 'volt/reactive/event_chain'
+require 'volt/reactive/object_tracker'
+
+DEBUG = false
+
+# A listener gets returned when adding an 'on' event listener.  It can be
+# used to clear the event listener.
+class Listener
+  attr_reader :scope_provider
+  
+  def initialize(klass, event, scope_provider, callback)
+    @klass = klass
+    @event = event
+    @scope_provider = scope_provider
+    @callback = callback
+
+    if DEBUG && RUBY_PLATFORM == 'opal'
+      # puts "e: #{event} on #{klass.inspect}"
+      @@all_events ||= []
+      @@all_events << self
+      
+      # counts = {}
+      # @@all_events.each do |ev|
+      #   scope = (ev.scope_provider && ev.scope_provider.scope) || nil
+      #   
+      #   # puts `typeof(scope)`
+      #   if `typeof(scope) !== 'undefined'`
+      #     counts[scope] ||= 0
+      #     counts[scope] += 1
+      #   end
+      # end
+      # 
+      # puts counts.inspect
+      
+      `window.total_listeners = window.total_listeners || 0;`
+      `window.total_listeners += 1;`
+      `console.log(window.total_listeners);`
+    end
+  end
+  
+  def internal?
+    @internal
+  end
+  
+  def scope
+    @scope_provider && @scope_provider.scope
+  end
+  
+  def call(*args)
+    # raise "Triggered on removed: #{@event} on #{@klass2.inspect}" if @removed
+    if @removed
+      puts "Triggered on removed: #{@event}"
+      return
+    end
+    
+    # Queue a live value update
+    if @klass.reactive?
+      # We are working with a reactive value.  Its receiving an event meaning
+      # something changed.  Queue an update of the value it tracks.
+      @klass.object_tracker.queue_update
+      # puts "Queued: #{ObjectTracker.queue.inspect}"
+    end
+    
+    @callback.call(*args)
+  end
+
+  # Removes the listener from where ever it was created.
+  def remove
+    # puts "FAIL:" if @removed
+    raise "event #{@event} already removed" if @removed
+    
+    # puts "e rem: #{@event} on #{@klass.inspect}"
+    if DEBUG && RUBY_PLATFORM == 'opal'
+      @@all_events.delete(self) if @@all_events
+      
+      `window.total_listeners -= 1;`
+      `console.log("Rem", window.total_listeners);`
+    end
+    
+    
+    @removed = true
+    @klass.remove_listener(@event, self)
+
+    # puts "Removed Listener for: #{@event} - #{@scope_provider && @scope_provider.scope.inspect} from #{@klass.inspect}"
+
+    # We need to clear these references to free the memory
+    @scope_provider = nil
+    @callback = nil
+    # @klass2 = @klass
+    @klass = nil
+    # @event = nil
+
+  end
+  
+  def inspect
+    "<Listener:#{object_id} event=#{@event} scope=#{scope.inspect}#{' internal' if internal?}>"
+  end
+end
+
+module Events
+  attr_accessor :scope
+  # Add a listener for an event
+  def on(event, scope_provider=nil, &block) 
+    # puts "Register: #{event} on #{self.inspect}"   
+    event = event.to_sym
+    
+    new_listener = Listener.new(self, event, scope_provider, block)
+    
+    @listeners ||= {}
+    @listeners[event] ||= []
+    @listeners[event] << new_listener
+
+    first = @listeners[event].size == 1
+    add_event_to_chains(event) if first
+
+    # Let the included class know that an event was registered. (if it cares)
+    if self.respond_to?(:event_added)
+      # call event added passing the event, the scope, and a boolean if it
+      # is the first time this event has been added.
+      self.event_added(event, scope_provider, first)
+    end
+
+    return new_listener
+  end
+  
+  def event_chain
+    @event_chain ||= EventChain.new(self)
+  end
+
+  def listeners
+    @listeners || {}
+  end
+
+  # Typically you would call .remove on the listener returned from the .on
+  # method.  However, here you can also pass in the original proc to remove
+  # a listener
+  def remove_listener(event, listener)
+    event = event.to_sym
+    
+    raise "Unable to delete #{event} from #{self.inspect}" unless @listeners && @listeners[event]
+    
+    # if @listeners && @listeners[event]
+      @listeners[event].delete(listener)
+
+      no_more_events = @listeners[event].size == 0
+      if no_more_events
+        remove_event_from_chains(event)
+
+        # No registered listeners now on this event
+        @listeners.delete(event)
+      end
+
+      # Let the class we're included on know that we removed a listener (if it cares)
+      if self.respond_to?(:event_removed)
+        # Pass in the event and a boolean indicating if it is the last event
+        self.event_removed(event, no_more_events)
+      end
+    # end
+  end
+  
+  # When events get added, we need to notify event chains so they
+  # can update and chain any new events.
+  def add_event_to_chains(event)
+    # First time this event is added, update any chains
+    event_chain.add_event(event)
+
+    # We need to keep the event chain's updated for any objects we're
+    # following for events.
+    event_followings.each {|ef| ef.event_chain.add_event(event) }
+
+    if event != :changed && !@other_event_listener
+      @other_event_listener = on('changed') { }
+    end
+  end
+  
+  # When events are removed, we need to notify any relevent chains so they
+  # can remove any chained events.
+  def remove_event_from_chains(event)
+    event_chain.remove_event(event)
+    
+    # We need to keep the event chain's updated for any objects we're
+    # following for events.
+    event_followings.each {|ef| ef.event_chain.remove_event(event) }
+
+    if event != :changed
+      # See if there are any remaining events that aren't changed
+      if listeners.keys.reject {|k| k == :changed }.size == 0
+        @other_event_listener.remove
+        @other_event_listener = nil
+      end
+    end
+  end
+  
+  
+  # Track the current object that we're following.
+  def event_followings
+    @event_followings || []
+  end
+
+  def add_following(object)
+    @event_followings ||= []
+    @event_followings << object
+    
+    # Take all of our listeners and add them to the 
+    listeners.keys.each do |event|
+      object.event_chain.add_event(event)
+    end
+  end
+  
+  def remove_following(object) 
+    @event_followings.delete(object)
+       
+    listeners.keys.each do |event|
+      object.event_chain.remove_event(event)
+    end
+  end
+  
+  # Track who's following us
+  def event_followers
+    @event_followers || []
+  end
+  
+  def add_event_follower(follower)
+    @event_followers ||= []
+    @event_followers << follower
+    
+    follower.add_following(self)
+  end
+  
+  def remove_event_follower(follower)
+    if @event_followers
+      @event_followers.delete(follower)
+    
+      follower.remove_following(self)
+    end
+  end
+
+  # Return all listeners for an event on the current object and any event 
+  # following objects.
+  def all_listeners_for(event)
+    # TODO: We dup at the moment because some events unregister events, is there
+    # a better solution than this?
+    all_listeners = []
+    all_listeners += @listeners[event].dup if @listeners && @listeners[event]
+
+    if @event_followers
+      @event_followers.each do |event_follower|
+        ef_listeners = event_follower.listeners
+        all_listeners += ef_listeners[event].dup if ef_listeners[event]
+      end
+    end
+    
+    return all_listeners
+  end
+
+  def trigger!(event, *args)
+    ObjectTracker.process_queue if !reactive? && !respond_to?(:skip_current_queue_flush)
+    
+    event = event.to_sym
+    
+    all_listeners_for(event).each do |listener|
+      # Call the event on each listener
+      listener.call(*args)
+    end
+
+    nil
+  end
+  
+  # Takes a block, which passes in 
+  def trigger_by_scope!(event, *args, &block)
+    ObjectTracker.process_queue if !reactive? && !respond_to?(:skip_current_queue_flush)
+    
+    event = event.to_sym
+    
+    all_listeners_for(event).each do |listener|
+      # Call the block, pass in the scope
+      if block.call(listener.scope)
+        listener.call(*args)
+      end
+    end
+  end
+
+end