query_dam 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0612b6f926d6c396e8a7be1e4a8c5c6ab2a888d7
-  data.tar.gz: a8973faabf07ffeb5afeb3540b1def06187ca51a
+  metadata.gz: 801eba4331fd983c0db84d269e8d327a82ebd5d1
+  data.tar.gz: 32988056b1e8a66e56b277ed380f13d338595186
 SHA512:
-  metadata.gz: 44d012c14b7e738279bd545156efd54a93d65dcc965031223c4fe73b4ff9cd8da66d7aa19ddc311901a67950a544f8e951b2b0af6eb2fd4c15ac526f97655a5c
-  data.tar.gz: a294b14782c0b07cb595061b511407aada190ee135e065a5dd6a54c4d6c097bcec10d18fa440a4be906cbf82ed28e92ca6a5c9625e9f1d2f93669bd7f7f73d18
+  metadata.gz: 0f6d274864e35f8692ced8092c5907624dcd9ffe26578db66559c4618e4067cb2ff2c5f2cd1afaaacbd447f8d191db889a05fcc8be87b639d0dd078e15456cc1
+  data.tar.gz: 83c8ed5b184a71a35eaf20b0362afa26de28affddcd6a8e5918a72d06c90fc02b50273396a8c9bc605b3d96e1e6da5dd9614758f80a2f7f4db3e0f66e7e0d2a0

data/.travis.yml

@@ -0,0 +1,4 @@
+rvm:
+  - 2.1.1
+
+script: 'bundle exec rake spec'

data/README.md

@@ -1,4 +1,5 @@
 # QueryDam
+[![Build Status](https://travis-ci.org/romankuznietsov/query_dam.svg)](https://travis-ci.org/romankuznietsov/query_dam)
 
 QueryDam is a tool for observing changes in ActiveRecord relation results.
 
@@ -10,7 +11,7 @@ Add it to your gemfile Gemfile:
 
 ## Usage
 
-First, include `QueryDam::Trackable` in every model you with to track.
+First, include `QueryDam::Trackable` in every model you want to track.
 
 ~~~ruby
 class Item < ActiveRecord::Base
@@ -18,7 +19,7 @@ class Item < ActiveRecord::Base
 end
 ~~~
 
-Then start watching updates of relation:
+Then start watching updates of the relation:
 
 ~~~ruby
 relation = Item.where(name: 'pencil')
@@ -27,9 +28,9 @@ tracking_key = QueryDam.watch_relation(relation)
 
 To get updates, call `QueryDam.get_updates(tracking_key)`.
 The result is a hash with 3 keys: 
-`:model` - the model of the relation,
-`:updates` - relation containing records that were updated or entered the scope of the relation
-`:exclusions` - array of ids of records that left the scope of the relation
+* `:model` - the model of the relation,
+* `:updates` - relation containing records that were updated or entered the scope of the relation
+* `:exclusions` - array of ids of records that left the scope of the relation
 
 The call to `get_updates` clears updates/exclusions.
 
@@ -47,7 +48,7 @@ QueryDam.get_updates(tracking_key)
 #  :updates=>#<ActiveRecord::Relation []>, 
 #  :exclusions=>[]}
 
-Item.first.destory
+Item.first.destroy
 
 QueryDam.get_updates(tracking_key)
 # =>

data/Rakefile

@@ -1,2 +1,6 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
+task default: :spec
+
+RSpec::Core::RakeTask.new(:spec)

data/lib/query_dam/concerns/trackable.rb

@@ -1,51 +1,74 @@
+require 'pry'
+
 module QueryDam
   module Trackable
     extend ActiveSupport::Concern
 
     included do
-      before_save :save_previous_query_dam_status
-      before_destroy :save_previous_query_dam_status
-      after_commit :update_query_dam
+      before_save :get_prior_results
+      before_destroy :get_prior_results
+      after_commit :update_queries
     end
 
-    def save_previous_query_dam_status
-      return unless persisted?
+    def get_prior_results
+      @_prior_results = {}
 
-      @_query_dam_previous_status = {}
-      queries_set = Redis::Set.new(self.class.name)
-      queries_set.members.each do |key|
-        query_hash = Redis::HashKey.new(key)
+      queries.each do |key, query_hash|
+        query = query_hash[:query]
 
-        unless query_hash.exists?
-          queries_set.delete(key)
-          next
+        @_prior_results[key] =
+          self.class.connection.select_values(query).map(&:to_i)
+      end
+    end
+
+    def update_queries
+      queries.each do |key, query_hash|
+        query = query_hash[:query]
+        result = self.class.connection.select_values(query).map(&:to_i)
+        added = result - @_prior_results[key]
+        removed = @_prior_results[key] - result
+
+        if result.include?(id)
+          QueryDam.updates_set(key) << id
+        end
+
+        additions_set = QueryDam.additions_set(key)
+        updates_set = QueryDam.updates_set(key)
+        removals_set = QueryDam.removals_set(key)
+
+        if result.include?(id)
+          updates_set.add(id)
         end
 
-        query = query_hash[:query].gsub(key, id.to_s)
+        added.each do |record_id|
+          if removals_set.member?(record_id)
+            removals_set.delete(record_id)
+          else
+            additions_set.add(record_id)
+          end
+        end
 
-        @_query_dam_previous_status[key] =
-          self.class.find_by_sql(query).any?
+        removed.each do |record_id|
+          updates_set.delete(record_id)
+
+          if additions_set.member?(record_id)
+            additions_set.delete(record_id)
+          else
+            removals_set.add(record_id)
+          end
+        end
       end
     end
 
-    def update_query_dam
+    def queries
       queries_set = Redis::Set.new(self.class.name)
-      queries_set.members.each do |key|
+      queries_set.members.reduce({}) do |acc, key|
         query_hash = Redis::HashKey.new(key)
-
-        unless query_hash.exists?
+        if query_hash.exists?
+          acc.merge(key => query_hash)
+        else
           queries_set.delete(key)
-          next
-        end
-
-        query = query_hash[:query].gsub(key, id.to_s)
-
-        if self.class.find_by_sql(query).any?
-          QueryDam.updates_set(key) << id
-          QueryDam.exclusions_set(key).delete id
-        elsif @_query_dam_previous_status[key]
-          QueryDam.updates_set(key).delete id
-          QueryDam.exclusions_set(key) << id
+          acc
         end
       end
     end

data/lib/query_dam/version.rb

@@ -1,3 +1,3 @@
 module QueryDam
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/query_dam.rb

@@ -12,10 +12,10 @@ module QueryDam
   class << self
     def watch_relation(relation)
       key = SecureRandom.uuid
-      query = relation.where("`#{relation.model.table_name}`.`id` = #{key}").to_sql
+      query = relation.select("`#{relation.model.table_name}`.`id`").to_sql
       query_hash = Redis::HashKey.new(key)
       query_hash.bulk_set(model: relation.model.name, query: query)
-      query_hash.expire(QUERY_EXPIRE)
+      # query_hash.expire(QUERY_EXPIRE)
       Redis::Set.new(relation.model.name) << key
       key
     end
@@ -26,23 +26,26 @@ module QueryDam
 
       model = query_hash[:model].constantize
 
+      updated_ids = (additions_set(key).members +
+                     updates_set(key).members).uniq
+      removed_ids = removals_set(key).members
+
       result = {
         model: model,
-        updates: model.where(id: updates_set(key).to_a),
-        exclusions: exclusions_set(key).to_a.map(&:to_i) }
+        updates: model.where(id: updated_ids),
+        exclusions: removed_ids.map(&:to_i) }
 
+      additions_set(key).clear
       updates_set(key).clear
-      exclusions_set(key).clear
+      removals_set(key).clear
 
       result
     end
 
-    def updates_set(key)
-      Redis::Set.new("#{key}-updates")
-    end
-
-    def exclusions_set(key)
-      Redis::Set.new("#{key}-exclusions")
+    %w[additions updates removals].each do |set_type|
+      define_method "#{set_type}_set" do |key|
+        Redis::Set.new("#{key} #{set_type}")
+      end
     end
   end
 end

data/query_dam.gemspec

@@ -26,4 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 3.0.0'
   spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'fakeredis'
+  spec.add_development_dependency 'pry'
 end

data/spec/query_dam_spec.rb

@@ -1,53 +1,106 @@
 describe QueryDam do
-  let!(:relation) { Item.where(name: 'pencil') }
-  let!(:key) { QueryDam.watch_relation(relation) }
+  describe 'simple query' do
+    let!(:relation) { Item.where(name: 'pencil') }
+    let!(:key) { QueryDam.watch_relation(relation) }
 
-  specify 'item enters scope on creation' do
-    item = Item.create(name: 'pencil')
+    specify 'item enters scope on creation' do
+      item = Item.create(name: 'pencil')
 
-    expect(QueryDam.get_updates(key)).to eq(
-      {model: Item, updates: [item], exclusions: []})
+      expect(QueryDam.get_updates(key)).to eq(
+        {model: Item, updates: [item], exclusions: []})
 
-    expect(QueryDam.get_updates(key)).to eq(
-      {model: Item, updates: [], exclusions: []})
-  end
+      expect(QueryDam.get_updates(key)).to eq(
+        {model: Item, updates: [], exclusions: []})
+    end
 
-  specify 'item enters scope on update' do
-    item = Item.create
+    specify 'item enters scope on update' do
+      item = Item.create
 
-    expect(QueryDam.get_updates(key)).to eq(
-      {model: Item, updates: [], exclusions: []})
+      expect(QueryDam.get_updates(key)).to eq(
+        {model: Item, updates: [], exclusions: []})
 
-    item.update_attributes!(name: 'pencil')
+      item.update_attributes!(name: 'pencil')
 
-    expect(QueryDam.get_updates(key)).to eq(
-      {model: Item, updates: [item], exclusions: []})
-  end
+      expect(QueryDam.get_updates(key)).to eq(
+        {model: Item, updates: [item], exclusions: []})
+    end
 
-  specify 'item leaves scope on update' do
-    item = Item.create(name: 'pencil')
-    QueryDam.get_updates(key)
+    specify 'item leaves scope on update' do
+      item = Item.create(name: 'pencil')
+      QueryDam.get_updates(key)
 
-    item.update_attributes!(name: 'pen')
-    expect(QueryDam.get_updates(key)).to eq(
-      {model: Item, updates: [], exclusions: [item.id]})
-  end
+      item.update_attributes!(name: 'pen')
+      expect(QueryDam.get_updates(key)).to eq(
+        {model: Item, updates: [], exclusions: [item.id]})
+    end
 
-  specify 'item leaves scope on deletion' do
-    item = Item.create(name: 'pencil')
-    QueryDam.get_updates(key)
+    specify 'item leaves scope on deletion' do
+      item = Item.create(name: 'pencil')
+      QueryDam.get_updates(key)
 
-    item.destroy
-    expect(QueryDam.get_updates(key)).to eq(
-      {model: Item, updates: [], exclusions: [item.id]})
+      item.destroy
+      expect(QueryDam.get_updates(key)).to eq(
+        {model: Item, updates: [], exclusions: [item.id]})
+    end
+
+    specify 'items gets updated' do
+      item = Item.create(name: 'pencil')
+      QueryDam.get_updates(key)
+
+      item.update_attributes!(quantity: 1)
+      expect(QueryDam.get_updates(key)).to eq(
+        {model: Item, updates: [item], exclusions: []})
+    end
   end
 
-  specify 'items gets updated' do
-    item = Item.create(name: 'pencil')
-    QueryDam.get_updates(key)
+  describe 'query with limit/offset' do
+    let!(:item_a) { Item.create!(name: 'a') }
+    let!(:item_b) { Item.create!(name: 'b') }
+    let!(:item_c) { Item.create!(name: 'c') }
+    let!(:item_d) { Item.create!(name: 'd') }
+
+    let!(:relation) { Item.order('name asc').limit(2).offset(2) }
+    let!(:key) { QueryDam.watch_relation(relation) }
+
+    specify 'item is not on page, but shifts it' do
+      Item.create!(name: 'a1')
+
+      expect(QueryDam.get_updates(key)).to eq (
+        {model: Item, updates: [item_b], exclusions: [item_d.id]})
+    end
+
+    specify 'item appears on page' do
+      item_b1 = Item.create(name: 'b1')
+      expect(QueryDam.get_updates(key)).to eq (
+        {model: Item, updates: [item_b1], exclusions: [item_d.id]})
+    end
+
+    specify 'item on page is updated' do
+      item_c.update_attributes(quantity: 1)
+      expect(QueryDam.get_updates(key)).to eq (
+        {model: Item, updates: [item_c], exclusions: []})
+    end
+
+    specify 'two updates lead to no changes' do
+      item_c1 = Item.create(name: 'c1')
+      item_c1.destroy
+      expect(QueryDam.get_updates(key)).to eq (
+        {model: Item, updates: [], exclusions: []})
+    end
+
+    specify 'item is updated and removed' do
+      item_d.update_attributes!(quantity: 1)
+      item_d.destroy
+      expect(QueryDam.get_updates(key)).to eq (
+        {model: Item, updates: [], exclusions: [item_d.id]})
+    end
 
-    item.update_attributes!(quantity: 1)
-    expect(QueryDam.get_updates(key)).to eq(
-      {model: Item, updates: [item], exclusions: []})
+    specify 'item is added, updated and removed' do
+      item_c1 = Item.create(name: 'c1')
+      item_c1.update_attributes(quantity: 1)
+      item_c1.destroy
+      expect(QueryDam.get_updates(key)).to eq (
+        {model: Item, updates: [], exclusions: []})
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'query_dam'
 require 'active_record'
 require 'models/item'
+require 'fakeredis/rspec'
 
 RSpec.configure do |config|
   config.order = :random
@@ -13,6 +14,10 @@ RSpec.configure do |config|
     mocks.syntax = :expect
     mocks.verify_partial_doubles = true
   end
+
+  config.after(:each) do
+    Item.destroy_all
+  end
 end
 
 ActiveRecord::Base.establish_connection(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: query_dam
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Roman Kuznietsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-27 00:00:00.000000000 Z
+date: 2014-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -108,6 +108,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ''
 email:
 - roman.kuznietsov@gmail.com
@@ -117,6 +145,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md