relix 1.3.0 → 1.4.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDQwM2VkOWJiYjk5NGQzYmNiMjA4ZThjNzQ3ZDRmNmQzZDJmZjRlZg==
+  data.tar.gz: !binary |-
+    N2Q3YTYyZWEyNjk2YTFjOGNiODQ0MDhmMGFmNTY1NTI5NDUxODE2ZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YzI2MTNmZmVmYTVlNTllNmQ2NDhkOTUxYjkwM2IxNGQ0NGI1NjQzMGNiYmE3
+    NWUxNjIzYjk1YWI1OGNkODdlYTNiMmZlNTcwZjdmOWI0MzlmYzYwMjAxMzQw
+    YWM5NzAwZGU2ODE5ZmMzOGExMzY2NmE5OWE2NGYzZDdkMzczYzY=
+  data.tar.gz: !binary |-
+    ZTgxNzA5Y2I0YjZkMTVlYjM4NzBkYzUwYTAyNTExOTIwOTYwOGZlZWVmNjk3
+    Mjg3ZmVlNWQ2YWMyNGNhZWMzNzlhMTY1YjYwNWM0ZTNjMGU5YzY0ZTRmYTYz
+    MzdkY2E2NzczYTRlYTkyNjA0ZTY3M2ZkODZhNDNhYjM0OTBiZTk=

data/HISTORY.md

@@ -1,3 +1,8 @@
+### 1.4.0
+
+* Add #deindex_by_primary_key. (ntalbott)
+* Add license. (ntalbott)
+
 ### 1.3.0
 
 * Update redis-rb dependency to 3.0. (ntalbott)

data/README.md

@@ -2,12 +2,14 @@
 
 A Redis-backed indexing layer that can be used with any (or no) backend data storage.
 
+
 ## Rationale
 
 With the rise in popularity of non-relational databases, and the regular use of relational databases in non-relational ways, data indexing has become an aspect of data storage that you can't simply assume is handled for you. More and more applications are storing their data in databases that treat that stored data as opaque, and thus there's no query engine sitting on top of the data making sure that it can be quickly and flexibly looked up.
 
 Relix is a layer that can be added on to any model to make all the normal types of querying you want to do: equality, less than/greater than, in set, range, limit, etc., quick and painless. Relix depends on Redis to be awesome at what it does - blazingly fast operations on basic data types - and layers on top of that pluggable indexing of your data for fast lookup.
 
+
 ## Philosophy
 
 * Performance is paramount - be FAST.
@@ -17,6 +19,7 @@ Relix is a layer that can be added on to any model to make all the normal types
 ** Make continuous index repair easy since the chaos monkey could attack at any time.
 * Be pluggable; keep the core simple and allow easy extensibility
 
+
 ## Installation
 
 If you're using bundler, add Relix to your Gemfile:
@@ -92,6 +95,7 @@ Since the :primary_key index is ordered by insertion order, we've also declared
 
     p Transaction.lookup{|q| q[:by_created_at].all}  # => [4,2,1,3]
 
+
 ## Querying
 
 Relix uses a simple query language based on method chaining. A "root" query is passed in to the lookup block, and then query terms are chained off of it:
@@ -142,7 +146,6 @@ When there are multiple attributes, they are specified in a hash:
         {storage_state: 'cached', account_id: 'bob'}, limit: 10)
     end
 
-
 ### Space efficiency
 
 Model attributes that are indexed on but that never change can be marked as immutable to prevent them being stored (since they don't have to be reindexed). The primary key is marked immutable by default, but other attributes can be as well:
@@ -154,6 +157,19 @@ Model attributes that are indexed on but that never change can be marked as immu
 This can also provide concurrency benefits since the keys for the indexes on immutable attributes don't have to be watched for concurrent modification.
 
 
+## Deindexing
+
+You'll probably want to remove an object from the index at some point. To do that simply call `#deindex!` on it:
+
+    person.deindex!
+
+You can also remove something from the index even if you don't have the complete object in hand anymore; simply call `.deindex_by_primary_key!` on its class:
+
+    Person.deindex_by_primary_key!(44)
+
+The class-level `deindex_by_primary_key` cannot clean up immutable indexes other than the primary key (since the current value of immutable keys is not stored), so calling plain `deindex!` on an object is preferred.
+
+
 ## Index Types
 
 ### PrimaryKeyIndex
@@ -164,10 +180,9 @@ The primary key index is the only index that is required on a model. Under the c
       primary_key :id
     end
 
-**Supported Operators**: eq, all  
+**Supported Operators**: eq, all
 **Ordering**: insertion
 
-
 ### MultiIndex
 
 Multi indexes allow multiple matching primary keys per indexed value, and are ideal for one to many relationships. They can include an ordering, and are declared using #multi in the relix block:
@@ -176,10 +191,9 @@ Multi indexes allow multiple matching primary keys per indexed value, and are id
       multi :account_id, order: :created_at
     end
 
-**Supported Operators**: eq  
+**Supported Operators**: eq
 **Ordering**: can be ordered on any numeric attribute (default is the to_i of the indexed value)
 
-
 ### UniqueIndex
 
 Unique indexes will raise an error if the same value is indexed twice for a different primary key. They also provide super fast lookups. They are declared using #unique in the relix block:
@@ -190,7 +204,7 @@ Unique indexes will raise an error if the same value is indexed twice for a diff
 
 Unique indexes ignore nil values - they will not be indexed and an error is not raised if there is more than one object with a value of nil. A multi-value unique index will be completely skipped if any value in it is nil.
 
-**Supported Operators**: eq, all  
+**Supported Operators**: eq, all
 **Ordering**: can be ordered on any numeric attribute (default is the to_i of the indexed value)
 
 ### OrderedIndex
@@ -202,7 +216,7 @@ primary keys per indexed value. They are declared using #ordered in the relix bl
       ordered :birthdate
     end
 
-**Supported Operators**: eq, lt, lte, gt, gte, order, limit, offset  
+**Supported Operators**: eq, lt, lte, gt, gte, order, limit, offset
 **Ordering**: ordered ascending by the indexed value, but can be queried in
   reverse order if you use `order(:desc)`.
 
@@ -218,6 +232,7 @@ Ordered indexes support a flexible fluent interface for specifying the query:
 
 This query returns the primary keys of the 10 youngest people born in 1990.
 
+
 ## Keying
 
 A big part of using Redis well is choosing solid keys; Relix has a pluggable keying infrastructure that makes it easy to use different key names for different situations. This actually rose out of the fact that the first release of Relix had a pathetic set of keys, and the need to support existing deployments while moving to something better going forward. Keyers are set on a per-model basis along with other configuration:

data/lib/relix/core.rb

@@ -25,6 +25,10 @@ module Relix
     def lookup(&block)
       relix.lookup(&block)
     end
+
+    def deindex_by_primary_key!(pk)
+      relix.deindex_by_primary_key!(pk)
+    end
   end
 
   def relix

data/lib/relix/index_set.rb

@@ -113,7 +113,22 @@ module Relix
           end
 
           ((watch = index.watch(old_value)) && @redis.watch(*watch))
-          proc { index.deindex(@redis, pk, object, old_value) }
+          proc { index.deindex(@redis, pk, old_value) }
+        end.tap { |ops| ops << proc { @redis.del current_values_name } }
+      end
+    end
+
+    def deindex_by_primary_key!(pk)
+      handle_concurrent_modifications(pk) do
+        current_values_name = current_values_name(pk)
+        @redis.watch current_values_name
+        current_values = @redis.hgetall(current_values_name)
+
+        indexes.map do |name, index|
+          old_value = current_values[name]
+
+          ((watch = index.watch(old_value)) && @redis.watch(*watch))
+          proc { index.deindex(@redis, pk, old_value) }
         end.tap { |ops| ops << proc { @redis.del current_values_name } }
       end
     end

data/lib/relix/indexes/multi.rb

@@ -11,7 +11,7 @@ module Relix
       r.zrem(key_for(old_value), pk)
     end
 
-    def deindex(r, pk, object, old_value)
+    def deindex(r, pk, old_value)
       r.zrem(key_for(old_value), pk)
     end
 
@@ -30,4 +30,4 @@ module Relix
     end
   end
   register_index MultiIndex
-end
+end

data/lib/relix/indexes/ordered.rb

@@ -19,7 +19,7 @@ module Relix
       r.zadd(sorted_set_name, score(object, value), pk)
     end
 
-    def deindex(r, pk, object, old_value)
+    def deindex(r, pk, old_value)
       r.zrem(sorted_set_name, pk)
     end
 

data/lib/relix/indexes/primary_key.rb

@@ -23,7 +23,7 @@ module Relix
       r.zadd(name, rank, pk)
     end
 
-    def deindex(r, pk, object, old_value)
+    def deindex(r, pk, old_value)
       r.zrem(name, pk)
     end
 

data/lib/relix/indexes/unique.rb

@@ -33,7 +33,7 @@ module Relix
       r.hdel(hash_name, old_value)
     end
 
-    def deindex(r, pk, object, old_value)
+    def deindex(r, pk, old_value)
       r.hdel(hash_name, old_value)
       r.zrem(sorted_set_name, pk)
     end
@@ -49,4 +49,4 @@ module Relix
   register_index UniqueIndex
 
   class NotUniqueError < Relix::Error; end
-end
+end

data/lib/relix/version.rb

@@ -1,3 +1,3 @@
 module Relix
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

metadata

@@ -1,38 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: relix
 version: !ruby/object:Gem::Version
-  version: 1.3.0
-  prerelease: 
+  version: 1.4.0
 platform: ruby
 authors:
 - Nathaniel Talbott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-11 00:00:00.000000000 Z
+date: 2013-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  prerelease: false
   name: hiredis
-  requirement: &70128679226480 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.4.1
   type: :runtime
-  prerelease: false
-  version_requirements: *70128679226480
 - !ruby/object:Gem::Dependency
+  prerelease: false
   name: redis
-  requirement: &70128679224880 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
-  prerelease: false
-  version_requirements: *70128679224880
 description: ! 'Relix is a layer that can be added on to any model to make all the
   normal types of querying you want to do: equality, less than/greater than, in set,
   range, limit, etc., quick and painless. Relix depends on Redis to be awesome at
@@ -59,28 +64,28 @@ files:
 - lib/relix/redis.rb
 - lib/relix/version.rb
 homepage: http://github.com/ntalbott/relix
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.5.2
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A Redis-backed indexing layer that can be used with any (or no) backend data
   storage.
 test_files: []