volt 0.9.6 → 0.9.7.pre2

data/lib/volt/queries/live_query_pool.rb

@@ -0,0 +1,58 @@
+require 'volt/queries/live_query'
+require 'volt/utils/generic_pool'
+
+# LiveQueryPool runs on the server and keeps track of all outstanding
+# queries.
+module Volt
+  class LiveQueryPool < Volt::GenericPool
+    attr_reader :volt_app
+
+    def initialize(data_store, volt_app)
+      @data_store = data_store
+      @volt_app = volt_app
+      super()
+    end
+
+    def lookup(collection, query)
+      super(collection, query)
+    end
+
+    def updated_collection(collection, skip_channel, from_message_bus=false)
+      # collection = collection.to_sym
+      lookup_all(collection).each do |live_query|
+        live_query.update(skip_channel)
+      end
+
+      msg_bus = @volt_app.message_bus
+      if !from_message_bus && collection != 'active_volt_instances' && msg_bus
+        msg_bus.publish('volt_collection_update', collection)
+      end
+    end
+
+    # Show a live updating list of the current live queries
+    if RUBY_PLATFORM == 'opal'
+      def live_log
+        Thread.new do
+          loop do
+            puts "------ live queries ------"
+            @pool.each do |live_query|
+              puts live_query.inspect
+            end
+
+            sleep 2
+          end
+        end
+      end
+    end
+
+    private
+
+    # Creates the live query if it doesn't exist, and stores it so it
+    # can be found later.
+    def create(collection, query = {})
+      # collection = collection.to_sym
+      # If not already setup, create a new one for this collection/query
+      LiveQuery.new(@volt_app, self, @data_store, collection, query)
+    end
+  end
+end

data/lib/volt/queries/query_association_splitter.rb

@@ -0,0 +1,31 @@
+# The QueryAssociationSplitter takes in a query and removes any .includes, and
+# returns the new query, and an hash of association parts.
+#
+# Example:
+#  QueryAssociationSplitter.split([['where', {name: 'Bob'}], ['includes', [:posts, [:posts, :comments], :links]]])
+#    => ['where', {name: 'Bob'}], {:posts=>{:comments=>{}}, :links=>{}}]
+module Volt
+  class QueryAssociationSplitter
+    def self.split(query)
+      new_query = []
+      associations = {}
+      query.each do |method, *args|
+        method = method.to_sym
+        if method == :includes
+          args.flatten(1).each do |path|
+            path = [path].flatten
+
+            node = associations
+            path.each do |part|
+              node = (node[part] ||= {})
+            end
+          end
+        else
+          new_query << [method, *args]
+        end
+      end
+
+      return new_query, associations
+    end
+  end
+end

data/lib/volt/queries/query_diff.rb

@@ -0,0 +1,100 @@
+# QueryDiff takes the results of a query and compares it to the previous
+# run.  It builds a diff that can be used to update, insert, and move models
+# to bring things up to date on the client.
+
+module Volt
+  class QueryDiff
+    # @param - initial run of the query(s)
+    # @param - is an array of symbols (or array of arrays of symbols) that
+    #          represent the associations:
+    #          Example: [:comments, [:comments, :user]]
+    def initialize(start_data, associations=[])
+      @old_data = start_data
+      @old_ids = start_data.map {|v| v[:id] }
+      @old_data_hash = hash_data(start_data)
+
+      @associations = associations
+    end
+
+    # returns the data keyed by id for faster lookup
+    def hash_data(array)
+      Hash[array.map { |r| [r[:id], r] }]
+    end
+
+    def run(new_data)
+      @new_data = new_data
+      @new_data_hash = hash_data(new_data)
+      @new_ids = new_data.map {|v| v[:id] }
+
+      @diff = []
+
+      detect_removed
+      detect_added_and_moved
+      detect_changed
+
+      @old_data = new_data
+      @old_data_hash = @new_data_hash
+      @old_ids = @new_ids
+
+      # return diff
+      @diff
+    end
+
+    def detect_removed
+      # Removed models
+      removed_ids = @old_ids - @new_ids
+      if removed_ids.size > 0
+        removed_ids.each do |r_id|
+          @diff << ['r', r_id]
+        end
+      end
+
+      # Update @old_ids to relect the removed
+      @old_ids &= @new_ids
+    end
+
+    # Loop through the new list, tracking in the old, notifies of any that
+    # have been added or moved.
+    def detect_added_and_moved
+      previous_index = 0
+
+      # we'll mutate the old_ids as we move through them to make it easier.
+      old_ids = @old_ids.dup
+      @new_ids.each_with_index do |id, index|
+        if (cur_previous = old_ids[previous_index]) && cur_previous == id
+          # Same in both previous and new
+          previous_index += 1
+          next
+        end
+
+        # We have an item that didn't match the current position's previous
+        # TODO: make a hash so we don't have to do include?
+        if old_ids.include?(id)
+          # The location from the previous has changed, move to correct location.
+
+          # Remove from old_idss, as it will be moved and we will be past it.
+          old_ids.delete(id)
+          @diff << ['m', id, index]
+        else
+          # Check for inserts
+          # TODO: Faster lookup
+          data = @new_data_hash[id]
+          @diff << ['i', index, data]
+        end
+      end
+    end
+
+    # Finds all items in the previous results that have new values, and alerts
+    # of changes.
+    def detect_changed
+      not_added_or_removed = @old_ids & @new_ids
+
+      not_added_or_removed.each do |id|
+        if @old_data_hash[id] != (data = @new_data_hash[id])
+          # Data hash changed
+          @diff << ['c', id, data]
+        end
+      end
+    end
+  end
+end

data/lib/volt/queries/query_runner.rb

@@ -0,0 +1,110 @@
+# The QueryRunner takes in a query and runs the query and any subqueries
+# needed to return the full results for an end users query.  .includes will be
+# parsed out (using QueryAssociationSplitter).
+#
+# When #run is called, it returns an Array of Hashes with the associations
+# filled in.
+
+require 'volt/queries/query_association_splitter'
+
+module Volt
+  class QueryRunner
+    attr_reader :associations
+
+    def initialize(data_store, collection, query)
+      @data_store = data_store
+
+      @collection = collection
+      # query and associations are immutable
+      @query, @associations = QueryAssociationSplitter.split(query)
+    end
+
+    # Runs the query and
+    def run
+      # When running through the query, run subqueries for any associations
+
+      # First run the root query
+      data = @data_store.query(@collection, @query)
+
+      parent_model = Volt::Model.class_at_path([@collection])
+
+      run_associations(data, parent_model, @associations)
+
+      data
+    end
+
+    # @param - the data hash for the root node
+    # @param - the path where the assocation data should be matched
+    # @param - a hash with the parts for the association
+    def run_associations(data, parent_model, associations)
+      associations.each_pair do |assoc, sub_assocs|
+        run_association(data, parent_model, assoc, sub_assocs)
+      end
+    end
+
+    def run_association(data, parent_model, assoc, sub_assocs)
+      assoc = assoc.to_sym
+      # Make another query to load in the association's data
+      # .where(post_id: parent_ids)
+      assoc_data = parent_model.associations[assoc.to_sym]
+
+      unless assoc_data
+        raise "`#{assoc}` was used in .includes(..), but is not a valid association"
+      end
+
+      foreign_key, local_key, collection = assoc_data.mfetch(
+        :foreign_key, :local_key, :collection
+      )
+
+      # Lookup the local_key from the association on the models
+      parent_ids = ids(data, local_key)
+
+      subquery = [[:where, {foreign_key => parent_ids}]]
+      results = @data_store.query(collection, subquery)
+
+      # For to many associations, we map to an array by id
+      results_by_assoc_id = if assoc_data[:to_many]
+        id_map_array(results, foreign_key)
+      else
+        id_map(results, foreign_key)
+      end
+
+      # Insert data into the original results
+      data.each do |row|
+        # Assign a field on the row for the child data
+        row[assoc] = results_by_assoc_id[row[local_key]]
+      end
+
+      # unless sub_associations == {}
+      #   # There are more associations off of this one
+
+      # end
+    end
+
+
+    private
+
+    # returns an array of ids
+    def ids(data, map_by=:id)
+      data.map {|v| v[map_by]}
+    end
+
+    # Takes in an array of hashes, and returns a hash of hashes keyed by id
+    def id_map(data, map_by=:id)
+      data.map {|v| [v[map_by], v] }.to_h
+    end
+
+    # like id_map, except it returns an array for multiple maps to the same id
+    def id_map_array(data, map_by=:id)
+      results = {}
+      data.each do |row|
+        key = row[map_by]
+        results[key] ||= []
+        results[key] << row
+      end
+
+      results
+    end
+
+  end
+end

data/lib/volt/queries/query_subscription.rb

@@ -0,0 +1,80 @@
+# The QuerySubscription keeps track of a LiveQuerry and a Channel which should be
+# updated when the LiveQuery changes.
+
+module Volt
+  class QuerySubscription
+    def initialize(live_query, channel)
+      @live_query = live_query
+      @channel = channel
+
+      if @channel
+        chan_subs = @live_query.volt_app.channel_query_subscriptions
+        chan_subs[@channel] ||= {}
+        chan_subs[@channel][self] = true
+      end
+
+      @old_data = []
+    end
+
+    def remove
+      # Remove from channel
+      if @channel
+        chan_subs = @live_query.volt_app.channel_query_subscriptions
+        subs_for_chan = chan_subs[@channel]
+        subs_for_chan.delete(self) if subs_for_chan
+      end
+
+      # Remove from the pool
+      @live_query.remove_query_subscription(@channel)
+    end
+
+    def initial_data
+      # puts "INITIAL DATA: #{@live_query.last_data.inspect}"
+      begin
+        # Filter the data first if we are working with models
+        filter_data(@live_query.last_data)
+      rescue => e
+        puts e.inspect
+        puts e.backtrace.join("\n")
+      end
+    end
+
+    def notify_updated(diff)
+      # puts "UPD: #{@live_query.collection.inspect}, #{@live_query.query.inspect}, #{diff.inspect}"
+      @channel.send_message('updated', nil, @live_query.collection, @live_query.query, diff)
+    end
+
+    # Filters data based on the user's permissions
+    def filter_data(data)
+      if data.is_a?(Array)
+        data.map do |data|
+          model = model_for_filter(data)
+
+          # @channel might be nil
+          Volt.as_user(@channel.try(:user_id)) do
+            model.filtered_attributes.sync
+          end
+        end
+      else
+        data
+      end
+    end
+
+    # Takes in data to be sent to the client and sets up a model to test
+    # field permissions against
+    def model_for_filter(data)
+      klass = Volt::Model.class_at_path([@live_query.collection])
+      model = nil
+
+      # Skip read validations when loading the model, no need to check read when checking
+      # permissions.
+      # TODO: We should probably document the possibility of data leak here, though really you
+      # shouldn't be storing anything inside of the permissions block.
+      Volt::Model.no_validate do
+        model = klass.new(data, {}, :loaded)
+      end
+
+      model
+    end
+  end
+end

data/lib/volt/queries/query_subscription_pool.rb

@@ -0,0 +1,37 @@
+require 'volt/queries/query_subscription'
+require 'volt/utils/generic_pool'
+
+# QuerySubscriptionPool keeps track of QuerySubscriptions
+module Volt
+  class QuerySubscriptionPool
+    def initialize(volt_app)
+      @pool = {}
+      @volt_app = volt_app
+    end
+
+    def lookup(*args)
+      @pool[[*args]] ||= begin
+        create(*args)
+      end
+    end
+
+    def remove(*args)
+      @pool.delete([*args])
+    end
+
+    def clear
+      @pool.values.each(&:remove)
+      @pool = {}
+    end
+
+    private
+
+    # Creates the live query if it doesn't exist, and stores it so it
+    # can be found later.
+    def create(collection, query, channel)
+      # collection = collection.to_sym
+      # If not already setup, create a new one for this collection/query
+      QuerySubscription.new(@volt_app, self, collection, query, channel)
+    end
+  end
+end

data/lib/volt/reactive/eventable.rb

@@ -70,6 +70,14 @@ module Volt
       listener
     end
 
+    # Same as on, but automatically removes itself after the call
+    def once(*events, &callback)
+      list = on(*events) do |*args, &block|
+        callback.call(*args, &block)
+        list.remove
+      end
+    end
+
     # Triggers event on the class the module was includeded.  Any .on listeners
     # will have their block called passing in *args.
     def trigger!(event, *args)

data/lib/volt/reactive/reactive_array.rb

@@ -24,10 +24,6 @@ module Volt
       @array.send(method_name, *args, &block)
     end
 
-    def ==(*args)
-      @array.==(*args)
-    end
-
     # At the moment, each just passes through.
     def each(&block)
       @array.each(&block)