volt 0.9.6 → 0.9.7.pre2

data/app/volt/tasks/live_query/live_query_pool.rb

@@ -1,48 +0,0 @@
-require_relative 'live_query'
-require 'volt/utils/generic_pool'
-
-# LiveQueryPool runs on the server and keeps track of all outstanding
-# queries.
-
-class LiveQueryPool < Volt::GenericPool
-  def initialize(data_store, volt_app)
-    @data_store = data_store
-    @volt_app = volt_app
-    super()
-  end
-
-  def lookup(collection, query)
-    # collection = collection.to_sym
-    query = normalize_query(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.run(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
-
-  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(self, @data_store, collection, query)
-  end
-
-  def normalize_query(query)
-    # TODO: add something to sort query properties so the queries are
-    # always compared the same.
-    query
-  end
-end

data/app/volt/tasks/live_query/query_tracker.rb

@@ -1,92 +0,0 @@
-# The query tracker runs queries and then tracks the changes
-# that take place.
-class QueryTracker
-  attr_accessor :results
-
-  def initialize(live_query, data_store)
-    @live_query = live_query
-    @data_store = data_store
-
-    # Stores the list of id's currently associated with this query
-    @current_ids = []
-    @results = []
-    @results_hash = {}
-  end
-
-  # Runs the query, stores the results and updates the current_ids
-  def run(skip_channel = nil)
-    @previous_results = @results
-    @previous_results_hash = @results_hash
-    @previous_ids = @current_ids
-
-    # Run the query again
-    @results = @data_store.query(@live_query.collection, @live_query.query)
-
-    # Update the current_ids
-    @current_ids = @results.map { |r| r[:id] }
-    @results_hash = Hash[@results.map { |r| [r[:id], r] }]
-
-    process_changes(skip_channel)
-  end
-
-  # Looks at the changes in the last run and sends out notices
-  # all changes.
-  def process_changes(skip_channel)
-    return unless @previous_ids
-
-    detect_removed(skip_channel)
-    detect_added_and_moved(skip_channel)
-    detect_changed(skip_channel)
-  end
-
-  def detect_removed(skip_channel)
-    # Removed models
-    removed_ids = @previous_ids - @current_ids
-    if removed_ids.size > 0
-      @live_query.notify_removed(removed_ids, skip_channel)
-    end
-
-    # Update @previous_ids to relect the removed
-    @previous_ids &= @current_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(skip_channel)
-    previous_index = 0
-    @current_ids.each_with_index do |id, index|
-      if (cur_previous = @previous_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 @previous_ids.include?(id)
-        # The location from the previous has changed, move to correct location.
-
-        # Remove from previous_ids, as it will be moved and we will be past it.
-        @previous_ids.delete(id)
-        @live_query.notify_moved(id, index, skip_channel)
-      else
-        # TODO: Faster lookup
-        data = @results_hash[id]
-        @live_query.notify_added(index, data, skip_channel)
-      end
-    end
-  end
-
-  # Finds all items in the previous results that have new values, and alerts
-  # of changes.
-  def detect_changed(skip_channel)
-    not_added_or_removed = @previous_ids & @current_ids
-
-    not_added_or_removed.each do |id|
-      if @previous_results_hash[id] != (data = @results_hash[id])
-        # Data hash changed
-        @live_query.notify_changed(id, data, skip_channel)
-      end
-    end
-  end
-end

data/spec/tasks/live_query_spec.rb

@@ -1,18 +0,0 @@
-if RUBY_PLATFORM != 'opal'
-  describe 'LiveQuery' do
-    before do
-      load File.join(File.dirname(__FILE__), '../../app/volt/tasks/live_query/live_query.rb')
-    end
-
-    it 'should run a query' do
-      pool = double('volt/pool')
-      data_store = double('volt/data store')
-
-      expect(data_store).to receive(:query).with('_items', {}).and_return([
-        { 'id' => 0, '_name' => 'one' }
-      ])
-
-      live_query = LiveQuery.new(pool, data_store, '_items', {})
-    end
-  end
-end

data/spec/tasks/query_tasks.rb

@@ -1,7 +0,0 @@
-if RUBY_PLATFORM != 'opal'
-  describe 'Volt::QueryTasks' do
-    before do
-      load File.join(File.dirname(__FILE__), '../../app/volt/tasks/query_tasks.rb')
-    end
-  end
-end

data/spec/tasks/query_tracker_spec.rb

@@ -1,145 +0,0 @@
-if RUBY_PLATFORM != 'opal'
-  describe 'LiveQuery' do
-    before do
-      load File.join(File.dirname(__FILE__), '../../app/volt/tasks/live_query/live_query.rb')
-    end
-
-    # LiveQueryStub behaves as the front-end would with the changes to a
-    # live query.  Instead of passing changes to the models to the front
-    # end, the changes are applied locally, then can be checked to see if
-    # the correct transitions have taken place.
-    class LiveQueryStub
-      attr_reader :collection, :query, :items
-      def initialize
-        @collection = '_items'
-        @query = {}
-        @items = []
-      end
-
-      def notify_removed(ids, skip_channel)
-        # Remove the id's that need to be removed
-        @items.reject! { |item| ids.include?(item[:id]) }
-      end
-
-      def notify_added(index, data, skip_channel)
-        @items.insert(index, data)
-      end
-
-      def notify_moved(id, index, skip_channel)
-        item = @items.find { |item| item[:id] == id }
-        @items.delete(item)
-
-        @items.insert(index, item)
-      end
-
-      def notify_changed(id, data, skip_channel)
-        item = @items.find { |item| item[:id] == id }
-        idx  = @items.index(item)
-        @items.delete(item)
-        @items.insert(idx, data)
-      end
-    end
-
-    before do
-      # Setup a live query stub
-      @live_query = LiveQueryStub.new
-      data_store = double('volt/data store')
-
-      # return an empty collection
-      @items = []
-      expect(data_store).to receive(:query).at_least(:once) { @items.dup }
-
-      @query_tracker = QueryTracker.new(@live_query, data_store)
-      @query_tracker.run
-    end
-
-    it 'should add items' do
-      @items = [
-        { id: 1, name: 'one' }
-      ]
-
-      expect(@live_query.items).to eq([])
-
-      @query_tracker.run
-
-      expect(@live_query.items).to eq(@items)
-    end
-
-    it 'should remove items' do
-      @items = [
-        { id: 1, name: 'one' },
-        { id: 2, name: 'two' }
-      ]
-      @query_tracker.run
-      expect(@live_query.items).to eq(@items)
-
-      @items = [
-        { id: 2, name: 'two' }
-      ]
-      @query_tracker.run
-      expect(@live_query.items).to eq(@items)
-    end
-
-    it 'should move items' do
-      @items = [
-        { id: 1, name: 'one' },
-        { id: 2, name: 'two' },
-        { id: 3, name: 'three' }
-      ]
-      @query_tracker.run
-      expect(@live_query.items).to eq(@items)
-
-      @items = [
-        { id: 2, name: 'two' },
-        { id: 3, name: 'three' },
-        { id: 1, name: 'one' }
-      ]
-      @query_tracker.run
-      expect(@live_query.items).to eq(@items)
-    end
-
-    it 'should handle complex transforms' do
-      @items = [
-        { id: 1, name: 'one' },
-        { id: 2, name: 'two' },
-        { id: 3, name: 'three' },
-        { id: 4, name: 'four' },
-        { id: 5, name: 'five' }
-      ]
-      @query_tracker.run
-      expect(@live_query.items).to eq(@items)
-
-      @items = [
-        { id: 7, name: 'seven' },
-        { id: 4, name: 'four' },
-        { id: 1, name: 'one' },
-        { id: 5, name: 'five' },
-        { id: 3, name: 'three' },
-        { id: 6, name: 'five' }
-      ]
-      @query_tracker.run
-      expect(@live_query.items).to eq(@items)
-    end
-
-    it 'should notify data hash has changed' do
-      @items = [
-        { id: 1, name: 'one' },
-        { id: 2, name: 'two' },
-        { id: 3, name: 'three' },
-        { id: 4, name: 'four' },
-        { id: 5, name: 'five' }
-      ]
-      @query_tracker.run
-      @items = [
-        { id: 1, name: 'some' },
-        { id: 2, name: 'values' },
-        { id: 3, name: 'have' },
-        { id: 4, name: 'changed' },
-        { id: 5, name: 'other' }
-      ]
-      expect(@live_query.items).to_not eq(@items)
-      @query_tracker.run
-      expect(@live_query.items).to eq(@items)
-    end
-  end
-end