relix 2.2.0 → 2.3.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OGM4Mzc2ZGI4YjZmNTBlYjczMjM4MjA0ZDE3YzM4ZGQ2ZmU1NTg0ZA==
-  data.tar.gz: !binary |-
-    MWRkMDg2ZTdlOWVmMmY2NWFkNDc1OGRiN2QwNThjZDc5NzQ2MzA2Zg==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MTU3YjZmNjYxOTEzODAxN2EyM2M3Nzk5ZWVhYTg5M2IyMGFkZDE0ZGIzMmYz
-    NjQyYmQ2MTc3NGU4Zjc1ZmU5ZTE0Yjc5NTNkOGFmN2I0NmYzZGZiZDkxYjYy
-    ZjBjYTY4MDlhYmQ5OTVlM2FiZWQzZWJhMTkyYTBmZTE3NjJiNzM=
-  data.tar.gz: !binary |-
-    NTdkZjBlMTE2YThjNTkyOTRkMWI4YWQ0ZGI4NTM2ZGY5ZDFlOTVhYTc3OWYw
-    MmQ0MmNlMjExZTYyOGU4YjY0ZmJjNGQyNWI1YjMwYmI5N2RlNTI1MDcxN2Fl
-    NTEzY2I4NjljZmU1ZTA3ZDhkYzQ2YjZlODcyNTgzYWZlNjFjNjE=
+SHA1:
+  metadata.gz: 3cd2735837da417e0b1d16ef57f3682e9dd298df
+  data.tar.gz: d205651a776733c1371cc6e4682c5112e183fdbb
+SHA512:
+  metadata.gz: 8fc398350349c460f237ec6de28a12120d9f22ade54e6f3694a93ecb6481e08433fb0b3e3ab643b77c06f79d3a6ee725cf3bb39233cbecfc3184ec0c68e45571
+  data.tar.gz: 0eaa69f08ace7ede18debe89bc534322bcdf036bc92af7a1265cfd8859e2b5c849b52f27537112fb18c61c8225e23692124c7d357b5e40e7968433937883ec18

data/HISTORY.md

@@ -1,3 +1,8 @@
+### 2.3.0
+
+* Add conditional indexing. (ntalbott)
+* Re-build current_values on each index run. (ntalbott)
+
 ### 2.2.0
 
 * Add index removal. (ntalbott)

data/README.md

@@ -163,6 +163,24 @@ Relix has some special handling for interrogative accessors (i.e. those ending w
 
 It also auto-casts `nil` to `false` and any other object to `true` for interrogative accessors, so that lookups work like you'd expect them to in a Ruby context. If you don't want to auto-casting, just alias your interrogative to a non-interrogative name and index on that instead.
 
+### Conditional Indexing
+
+Relix allows you to decide on a per-object basis whether a given index should be built:
+
+    class Person
+      include Relix
+      relix do
+        primary_key :key
+        multi :name, on: %w(first last), if: full_name?
+      end
+
+      def full_name?
+        (first && last)
+      end
+    end
+
+People will only be indexed now if they have both a first and a last name, otherwise they will not be included in the index at all. Note that this is also smart enough to deindex an object if its condition changes.
+
 ### 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:

data/lib/relix/index.rb

@@ -34,6 +34,7 @@ module Relix
       @model_name = @set.klass.name
       @accessors = Array(accessors).collect{|a| Accessor.new(a)}
       @attribute_immutable = options[:immutable_attribute]
+      @conditional = options[:if]
       @options = options
     end
 
@@ -77,6 +78,10 @@ module Relix
       true
     end
 
+    def index?(r, object, value)
+      (@conditional ? object.send(@conditional) : true)
+    end
+
     def query(r, value)
       nil
     end

data/lib/relix/index_set.rb

@@ -129,6 +129,7 @@ module Relix
       current_values_name = current_values_name(pk)
       redis.watch current_values_name
       current_values = redis.hgetall(current_values_name)
+      new_current_values = {}
 
       ops = full_index_list.collect do |name,index|
         value = index.read_normalized(object)
@@ -136,20 +137,31 @@ module Relix
 
         ((watch = index.watch(value, old_value)) && redis.watch(*watch))
 
-        next if value == old_value
-        current_values[name] = value unless index.attribute_immutable?
+        if index.index?(redis, object, value)
+          next if value == old_value
+          next unless index.filter(redis, object, value)
 
-        next unless index.filter(redis, object, value)
-
-        query_value = index.query(redis, value)
-        proc do
-          index.index(redis, pk, object, value, old_value, *query_value)
+          new_current_values[name] = value unless index.attribute_immutable?
+          query_value = index.query(redis, value)
+          proc do
+            index.index(redis, pk, object, value, old_value, *query_value)
+          end
+        else
+          proc do
+            index.deindex(redis, pk, old_value)
+          end
         end
       end.compact
 
-      ops << proc do
-        redis.hmset(current_values_name, *current_values.flatten)
-      end if current_values.any?
+      if new_current_values.any?
+        ops << proc do
+          redis.hmset(current_values_name, *new_current_values.flatten)
+        end
+      elsif current_values.any?
+        ops << proc do
+          redis.del(current_values_name)
+        end
+      end
 
       ops
     end

data/lib/relix/indexes/unique.rb

@@ -15,11 +15,15 @@ module Relix
     end
 
     def filter(r, object, value)
-      return true if read(object).values.any?{|e| e.nil?}
       if r.hexists(hash_name, value)
         raise NotUniqueError.new("'#{value}' is not unique in index #{name}")
       end
-      true
+      super
+    end
+
+    def index?(r, object, value)
+      return false if read(object).values.any?{|e| e.nil?}
+      super
     end
 
     def index(r, pk, object, value, old_value)

data/lib/relix/version.rb

@@ -1,5 +1,5 @@
 module Relix
-  VERSION = "2.2.0"
+  VERSION = "2.3.0"
   REDIS_VERSION = "2.6"
 
   class Version

metadata

@@ -1,48 +1,48 @@
 --- !ruby/object:Gem::Specification
 name: relix
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Nathaniel Talbott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-08 00:00:00.000000000 Z
+date: 2013-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: hiredis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.4.1
+  type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.4.1
-  type: :runtime
 - !ruby/object:Gem::Dependency
-  prerelease: false
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
+  type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
-  type: :runtime
-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
-  what it does - blazingly fast operations on basic data types - and layers on top
-  of that pluggable indexing of your data for fast lookup.'
+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 what it
+  does - blazingly fast operations on basic data types - and layers on top of that
+  pluggable indexing of your data for fast lookup.'
 email:
 - nathaniel@talbott.ws
 executables: []
@@ -73,17 +73,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.5.2
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A Redis-backed indexing layer that can be used with any (or no) backend data