relix 1.5.0 → 2.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzI0ZGYzYjgyYjdiMjlkN2ExZjA3MTk0ZjRkYTM3YmZiMmFjMjJlYQ==
+    MjY4Y2ExMjRhYTk5MTJjYjUyYTUwZjE4NWUxZDlmOGEwNGU5YWJjYw==
   data.tar.gz: !binary |-
-    YmZjNDU0NmUwMGI0NGY5OGE0ZjUxMTBkNmQyOGVjY2VhMTM2NmVhMA==
+    ZjA5NGFhODZhODYyYzZjZjA3MmU1ODA5YTkyM2Q2YWM4ZGZkNjJlYw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NDhjZjgyY2RjYTIzMWU0YmMyZjI5MDEwNTg4ZmVkYTZkYjRkYjBhYTBiZDZk
-    Yjk4MWQ1YjE0MjFmOTc4YzlhZWFhZjNiN2I0MWIwMTdkMmVjMDYxODIzMWNj
-    Y2RhMDU2MDI0ZTVmM2FiNjRhY2EzMDg5MDMzM2JhZGQ2Y2M5ZTY=
+    Yzg0NzA4YjczZTI0YzJkZmE2NTJlNzA1NWNkNWJkZTEyNzIzYTU1MjYzYjgz
+    YWQyYjQ2NjA0MzJmZThjMzJjYTY3YmYyNjZhNGRjYzFhNzhlNmViYWU3ODFl
+    ZDAwY2Y2OTc4NzFlMzVmNDlhYTMwMDI5ZGI4ZTE3ZGMwZDEwYTI=
   data.tar.gz: !binary |-
-    MjI1MDIyN2Y1ZDZiOGIwYjJlOGJlZDQ5NjNmZjdmMjc2ZWRmOWQ5NTAxNWNi
-    MTUzODBiZDM4NDdkZDI2ZTNkY2ZlNWYyNDI3NmE1MTk2N2YxZDNlYjFmNTA4
-    MjIyZGQ2MTk3NjdiMjAzMGQwYTc4ZWZhNmFkYzQ0MWE3ZDA5YzQ=
+    ZDA1ZTZjMDMxMzliMDIyZjZmZjIxZjk3MTYxOTAzYTk1NjhjODJiYzFiOTAx
+    NmZlMDQ4Y2JlNGIzN2RiMTI2MDk3MDM2ODg0NjI0OTg1YmExN2E0NDlmN2Yy
+    NjQyN2RkYjEzNTQ2YzA2NmIxMjIxMWVkMzE5NjE4ZDg0Y2M3MTk=

data/HISTORY.md

@@ -1,3 +1,10 @@
+### 2.0.0
+
+* Require Redis 2.6. (ntalbott)
+* Add deprecation support. (ntalbott)
+* Add proper API for accessing indexes by name. (ntalbott)
+* Add lookup of multi index values. (ntalbott)
+
 ### 1.5.0
 
 * Add special handling for interrogative methods. (ntalbott)

data/README.md

@@ -36,6 +36,8 @@ You can configure the Redis host, port and db like so:
     Relix.port = 10000
     Relix.db   = 5
 
+Relix requires Redis 2.6 or later.
+
 
 ## Usage
 
@@ -209,6 +211,24 @@ Multi indexes allow multiple matching primary keys per indexed value, and are id
 **Supported Operators**: eq
 **Ordering**: can be ordered on any numeric attribute (default is the to_i of the indexed value)
 
+#### Values
+
+If you declare the correct option, it's possible to pull the set of values that are being indexed on as well:
+
+    relix.multi :account_id, index_values: true
+
+    # Enables this call
+    relix.lookup_values(:account_id)
+
+This will yield all of the `account_ids` being indexed on, rather than the set of keys indexed by a particular set of `account_ids`. A typical use case would be fast iteration over grouped sub-models of a `many` relationship:
+
+    User.lookup_values(:account_id).each do |account_id|
+      users_for_account = User.lookup{|q| q[:account_id].eq(account_id)}
+      # Aggregate processing for the users in the account
+    end
+
+The ordering of returned values is undefined.
+
 ### 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:

data/lib/relix.rb

@@ -8,3 +8,4 @@ require 'relix/indexes/multi'
 require 'relix/indexes/unique'
 require 'relix/indexes/primary_key'
 require 'relix/indexes/ordered'
+require 'relix/version'

data/lib/relix/core.rb

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

data/lib/relix/index.rb

@@ -135,4 +135,5 @@ module Relix
 
   class UnorderableValueError < Relix::Error; end
   class MissingIndexValueError < Relix::Error; end
+  class ValuesNotIndexedError < Relix::Error; end
 end

data/lib/relix/index_set.rb

@@ -47,7 +47,8 @@ module Relix
     end
 
     def indexes
-      (parent ? parent.indexes.merge(@indexes) : @indexes)
+      Relix.deprecate("Calling #indexes is deprecated; use #[] instead.", "2")
+      self
     end
 
     def lookup(&block)
@@ -60,12 +61,16 @@ module Relix
       end
     end
 
+    def lookup_values(index)
+      self[index].values(@redis)
+    end
+
     def index_ops(object, pk)
       current_values_name = current_values_name(pk)
       @redis.watch current_values_name
       current_values = @redis.hgetall(current_values_name)
 
-      ops = indexes.collect do |name,index|
+      ops = full_index_list.collect do |name,index|
         value = index.read_normalized(object)
         old_value = current_values[name]
 
@@ -105,7 +110,7 @@ module Relix
         @redis.watch current_values_name
         current_values = @redis.hgetall(current_values_name)
 
-        indexes.map do |name, index|
+        full_index_list.map do |name, index|
           old_value = if index.attribute_immutable?
             index.read_normalized(object)
           else
@@ -124,7 +129,7 @@ module Relix
         @redis.watch current_values_name
         current_values = @redis.hgetall(current_values_name)
 
-        indexes.map do |name, index|
+        full_index_list.map do |name, index|
           old_value = current_values[name]
 
           ((watch = index.watch(old_value)) && !watch.empty? && @redis.watch(*watch))
@@ -149,7 +154,17 @@ module Relix
       keyer.values(pk, @klass)
     end
 
-  private
+    def [](name)
+      full_index_list[name.to_s]
+    end
+
+    protected
+
+    def full_index_list
+      (parent ? parent.full_index_list.merge(@indexes) : @indexes)
+    end
+
+    private
 
     def handle_concurrent_modifications(primary_key)
       retries = 5

data/lib/relix/indexes/multi.rb

@@ -3,16 +3,21 @@ module Relix
     include Ordering
 
     def watch_keys(*values)
-      values.compact.map { |v| key_for(v) }
+      keys = values.compact.map { |v| key_for(v) }
+      keys << values_key if index_values?
+      keys
     end
 
     def index(r, pk, object, value, old_value)
       r.zadd(key_for(value), score(object, value), pk)
-      r.zrem(key_for(old_value), pk)
+      index_value(r, value) if index_values?
+
+      deindex(r, pk, old_value)
     end
 
     def deindex(r, pk, old_value)
       r.zrem(key_for(old_value), pk)
+      deindex_value(r, old_value) if index_values?
     end
 
     def eq(r, value, options={})
@@ -28,6 +33,32 @@ module Relix
     def key_for(value)
       @set.keyer.component(name, value)
     end
+
+    def index_values?
+      @options[:index_values]
+    end
+
+    def values_key
+      @set.keyer.component(name, "_values")
+    end
+
+    def values(r)
+      raise ValuesNotIndexedError.new("Value indexing not enabled for #{name}.") unless index_values?
+      r.smembers(values_key)
+    end
+
+    def index_value(r, value)
+      r.sadd(values_key, value)
+    end
+
+    def deindex_value(r, old_value)
+      r.eval %(
+        if(redis.call("ZCARD", KEYS[2]) == 0) then
+          return redis.call("SREM", KEYS[1], ARGV[1])
+        end
+        return "OK"
+      ), [values_key, key_for(old_value)], [old_value]
+    end
   end
   register_index MultiIndex
 end

data/lib/relix/query.rb

@@ -6,7 +6,7 @@ module Relix
     end
 
     def [](index_name)
-      index = @model.indexes[index_name.to_s]
+      index = @model[index_name]
       raise MissingIndexError.new("No index declared for #{index_name}") unless index
       @clause = index.create_query_clause(@model.redis)
     end
@@ -49,4 +49,4 @@ module Relix
   end
 
   class MissingIndexError < Relix::Error; end
-end
+end

data/lib/relix/redis.rb

@@ -15,6 +15,10 @@ module Relix
 
   def self.new_redis_client
     ::Redis.new(host: @redis_host, port: @redis_port).tap do |client|
+      version = client.info["redis_version"]
+      if(Relix::Version.new(version) < Relix::REDIS_VERSION)
+        raise UnsupportedRedisVersion.new("Relix requires Redis >= #{Relix::REDIS_VERSION}; you have #{version}.")
+      end
       client.select @redis_db if @redis_db
     end
   end
@@ -30,4 +34,6 @@ module Relix
   def self.db=(value)
     @redis_db = value
   end
-end
+
+  class UnsupportedRedisVersion < Exception; end
+end

data/lib/relix/version.rb

@@ -1,3 +1,42 @@
 module Relix
-  VERSION = "1.5.0"
+  VERSION = "2.0.0"
+  REDIS_VERSION = "2.6"
+
+  class Version
+    include Comparable
+
+    attr_reader :major, :minor, :patch
+    def initialize(version)
+      @major, @minor, @patch = version.to_s.split(".").collect{|e| e.to_i}
+      @minor ||= 0
+      @patch ||= 0
+    end
+
+    def <=>(other)
+      case other
+      when String
+        (self <=> Version.new(other))
+      else
+        if((r = (major <=> other.major)) != 0)
+          r
+        elsif((r = (minor <=> other.minor)) != 0)
+          r
+        else
+          (patch <=> other.patch)
+        end
+      end
+    end
+  end
+
+  def self.deprecate(message, as_of_version)
+    as_of_version = Version.new(as_of_version)
+
+    if Version.new(VERSION).major > as_of_version.major
+      raise DeprecationError.new(message)
+    else
+      $stderr.puts(message)
+    end
+  end
+
+  class DeprecationError < Exception; end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relix
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Nathaniel Talbott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-16 00:00:00.000000000 Z
+date: 2013-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   prerelease: false