query_dam 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a4fd20c5b7ba8e610fd9757b7d1df78eed85b76
-  data.tar.gz: 7ed9a41bc2ffcb516c11753882d0a5de6032aab2
+  metadata.gz: 0612b6f926d6c396e8a7be1e4a8c5c6ab2a888d7
+  data.tar.gz: a8973faabf07ffeb5afeb3540b1def06187ca51a
 SHA512:
-  metadata.gz: 7129aa97a1b6618a0c394f26a04b1c1868722e0a118138531ad9fa4607ec01774c81d40003610d25840ebe2dd832faf1c35958698ce60b5d00ca797e429779a5
-  data.tar.gz: b97ac6cc7920020935cee268af83f1b1e37e047754ae29355619831412ea3673ab065a0c24fac7aeb9d1c81dc931fdbcf00df61ff4ab49640646799929a824df
+  metadata.gz: 44d012c14b7e738279bd545156efd54a93d65dcc965031223c4fe73b4ff9cd8da66d7aa19ddc311901a67950a544f8e951b2b0af6eb2fd4c15ac526f97655a5c
+  data.tar.gz: a294b14782c0b07cb595061b511407aada190ee135e065a5dd6a54c4d6c097bcec10d18fa440a4be906cbf82ed28e92ca6a5c9625e9f1d2f93669bd7f7f73d18

data/.gitignore

@@ -20,3 +20,4 @@ tmp
 *.o
 *.a
 mkmf.log
+*.sqlite3

data/.rspec

@@ -1,3 +1,2 @@
 --color
---warnings
 --require spec_helper

data/README.md

@@ -1,24 +1,60 @@
 # QueryDam
 
-TODO: Write a gem description
+QueryDam is a tool for observing changes in ActiveRecord relation results.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add it to your gemfile Gemfile:
 
     gem 'query_dam'
 
-And then execute:
+## Usage
 
-    $ bundle
+First, include `QueryDam::Trackable` in every model you with to track.
 
-Or install it yourself as:
+~~~ruby
+class Item < ActiveRecord::Base
+  include QueryDam::Trackable
+end
+~~~
 
-    $ gem install query_dam
+Then start watching updates of relation:
 
-## Usage
+~~~ruby
+relation = Item.where(name: 'pencil')
+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
+
+The call to `get_updates` clears updates/exclusions.
+
+~~~ruby
+Item.create(name: 'pencil')
+QueryDam.get_updates(tracking_key)
+# =>
+# {:model=>Item, 
+#  :updates=>#<ActiveRecord::Relation [#<Item id: 1, name: "pencil">]>, 
+#  :exclusions=>[]}
+
+QueryDam.get_updates(tracking_key)
+# =>
+# {:model=>Item, 
+#  :updates=>#<ActiveRecord::Relation []>, 
+#  :exclusions=>[]}
+
+Item.first.destory
 
-TODO: Write usage instructions here
+QueryDam.get_updates(tracking_key)
+# =>
+# {:model=>Item, 
+#  :updates=>#<ActiveRecord::Relation []>, 
+#  :exclusions=>[1]}
+~~~
 
 ## Contributing
 

data/lib/query_dam.rb

@@ -1,9 +1,48 @@
 require 'securerandom'
-require 'active_support/dependencies'
+require 'active_support/core_ext'
+require 'redis-objects'
 
 require 'query_dam/version'
+require 'query_dam/concerns/trackable'
 
 module QueryDam
-  autoload :Trackable, 'query_dam/concerns/trackable'
-  autoload :Cacheable, 'query_dam/concerns/cacheable'
+
+  QUERY_EXPIRE = 5.minutes
+
+  class << self
+    def watch_relation(relation)
+      key = SecureRandom.uuid
+      query = relation.where("`#{relation.model.table_name}`.`id` = #{key}").to_sql
+      query_hash = Redis::HashKey.new(key)
+      query_hash.bulk_set(model: relation.model.name, query: query)
+      query_hash.expire(QUERY_EXPIRE)
+      Redis::Set.new(relation.model.name) << key
+      key
+    end
+
+    def get_updates(key)
+      query_hash = Redis::HashKey.new(key)
+      return nil unless query_hash.exists?
+
+      model = query_hash[:model].constantize
+
+      result = {
+        model: model,
+        updates: model.where(id: updates_set(key).to_a),
+        exclusions: exclusions_set(key).to_a.map(&:to_i) }
+
+      updates_set(key).clear
+      exclusions_set(key).clear
+
+      result
+    end
+
+    def updates_set(key)
+      Redis::Set.new("#{key}-updates")
+    end
+
+    def exclusions_set(key)
+      Redis::Set.new("#{key}-exclusions")
+    end
+  end
 end

data/lib/query_dam/concerns/trackable.rb

@@ -3,23 +3,49 @@ module QueryDam
     extend ActiveSupport::Concern
 
     included do
-      after_save :update_cached_queries
-      after_destroy :update_cached_queries
+      before_save :save_previous_query_dam_status
+      before_destroy :save_previous_query_dam_status
+      after_commit :update_query_dam
     end
 
-    def update_cached_queries
-      Redis::Set.new(self.class.name).members.each do |query_id|
-        sql = Redis::HashKey.new(query_id)[:sql].gsub(query_id, id.to_s)
+    def save_previous_query_dam_status
+      return unless persisted?
 
-        updated_set = Redis::Set.new("#{query_id}_updated")
-        excluded_set = Redis::Set.new("#{query_id}_excluded")
+      @_query_dam_previous_status = {}
+      queries_set = Redis::Set.new(self.class.name)
+      queries_set.members.each do |key|
+        query_hash = Redis::HashKey.new(key)
 
-        if self.class.find_by_sql(sql).any?
-          updated_set << id
-          excluded_set.delete id
-        else
-          updated_set.delete id
-          excluded_set << id
+        unless query_hash.exists?
+          queries_set.delete(key)
+          next
+        end
+
+        query = query_hash[:query].gsub(key, id.to_s)
+
+        @_query_dam_previous_status[key] =
+          self.class.find_by_sql(query).any?
+      end
+    end
+
+    def update_query_dam
+      queries_set = Redis::Set.new(self.class.name)
+      queries_set.members.each do |key|
+        query_hash = Redis::HashKey.new(key)
+
+        unless query_hash.exists?
+          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
         end
       end
     end

data/lib/query_dam/version.rb

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

data/query_dam.gemspec

@@ -20,9 +20,9 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'redis', '>= 3.1.0'
   spec.add_dependency 'redis-objects', '>= 0.8.0'
-  spec.add_dependency 'activemodel', '>= 4.0.0'
+  spec.add_dependency 'activerecord', '>= 4.0.0'
 
-  spec.add_development_dependency 'bundler', "~> 1.6"
+  spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec', '~> 3.0.0'
   spec.add_development_dependency 'sqlite3'

data/spec/models/item.rb

@@ -0,0 +1,3 @@
+class Item < ActiveRecord::Base
+  include QueryDam::Trackable
+end

data/spec/query_dam_spec.rb

@@ -0,0 +1,53 @@
+describe QueryDam 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')
+
+    expect(QueryDam.get_updates(key)).to eq(
+      {model: Item, updates: [item], exclusions: []})
+
+    expect(QueryDam.get_updates(key)).to eq(
+      {model: Item, updates: [], exclusions: []})
+  end
+
+  specify 'item enters scope on update' do
+    item = Item.create
+
+    expect(QueryDam.get_updates(key)).to eq(
+      {model: Item, updates: [], exclusions: []})
+
+    item.update_attributes!(name: 'pencil')
+
+    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)
+
+    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)
+
+    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

data/spec/spec_helper.rb

@@ -1,3 +1,7 @@
+require 'query_dam'
+require 'active_record'
+require 'models/item'
+
 RSpec.configure do |config|
   config.order = :random
 
@@ -10,3 +14,17 @@ RSpec.configure do |config|
     mocks.verify_partial_doubles = true
   end
 end
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: 'spec/testdb.sqlite3')
+
+ActiveRecord::Base.connection.execute 'drop table if exists items'
+ActiveRecord::Base.connection.execute <<-SQL
+  create table items (
+    id integer primary key,
+    name varchar(255),
+    quantity integer)
+SQL
+
+Redis.current = Redis.new(host: '127.0.0.1', port: 6379)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: query_dam
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Roman Kuznietsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2014-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.8.0
 - !ruby/object:Gem::Dependency
-  name: activemodel
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
@@ -122,10 +122,11 @@ files:
 - README.md
 - Rakefile
 - lib/query_dam.rb
-- lib/query_dam/concerns/cacheable.rb
 - lib/query_dam/concerns/trackable.rb
 - lib/query_dam/version.rb
 - query_dam.gemspec
+- spec/models/item.rb
+- spec/query_dam_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/romankuznietsov/query_dam
 licenses:
@@ -152,4 +153,6 @@ signing_key:
 specification_version: 4
 summary: Detecting query result changes
 test_files:
+- spec/models/item.rb
+- spec/query_dam_spec.rb
 - spec/spec_helper.rb

data/lib/query_dam/concerns/cacheable.rb

@@ -1,34 +0,0 @@
-module QueryDam
-  module Cacheable
-    extend ActiveSupport::Concern
-
-    def cache_query(relation)
-      query_id = SecureRandom.uuid
-      sql = relation.where("`#{relation.model.table_name}`.`id` = #{query_id}").to_sql
-      Redis::HashKey.new(query_id).bulk_set(sql: sql, model: relation.model.name)
-      Redis::Set.new(relation.model.name) << query_id
-      query_id
-    end
-
-    def query_updates(query_ids)
-      query_ids.map do |query_id|
-        model = Redis::HashKey.new(query_id)[:model].constantize
-        updated_set = Redis::Set.new("#{query_id}_updated")
-        excluded_set = Redis::Set.new("#{query_id}_excluded")
-
-        updated_ids = updated_set.to_a
-        excluded_ids = excluded_set.to_a
-
-        updated_set.clear
-        excluded_set.clear
-
-        updated_records = model.where(id: updated_ids)
-        updated_records = yield(updated_records) if block_given?
-
-        {query_id: query_id,
-         updated: updated_records,
-         excluded: excluded_ids}
-      end
-    end
-  end
-end