relix 1.0.3 → 1.1.0

data/README.md

@@ -153,7 +153,7 @@ 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
 
 
@@ -165,7 +165,7 @@ 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)
 
 
@@ -179,5 +179,33 @@ 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
-**Ordering**: can be ordered on any numeric attribute (default is the to_i of the indexed value)
+**Supported Operators**: eq, all  
+**Ordering**: can be ordered on any numeric attribute (default is the to_i of the indexed value)
+
+
+## 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:
+
+    relix do
+      keyer Relix::Keyer::Compact
+    end
+
+You can set the default keyer like so:
+
+    Relix.default_keyer(Relix::Keyer::Compact)
+
+
+### Standard
+
+This keyer is nice and verbose, which makes it ideal for development since you can browse the Redis keyspace and see at a glance how the indexes are stored. **Standard is the default keyer.**
+
+
+### Compact
+
+Keys take up space, and especially since Redis holds the keyset in memory it can be a big boon with a large data set to keep key names short. The Compact keyer tries to balance a reasonable level of readability (we can't sacrifice the ability to debug production issues) with keeping keys as compact as possible.
+
+
+### Legacy
+
+This (eventually to be deprecated and removed) strategy exactly mirrors the keying supported by Relix when first released.

data/lib/relix.rb

@@ -1,4 +1,5 @@
 require 'relix/core'
+require 'relix/keyer'
 require 'relix/redis'
 require 'relix/query'
 require 'relix/index_set'

data/lib/relix/core.rb

@@ -8,13 +8,13 @@ module Relix
     @index_types ||= {}
   end
 
-  def self.register_index(name, index)
-    index_types[name.to_sym] = index
+  def self.register_index(index)
+    index_types[index.kind.to_sym] = index
   end
 
   module ClassMethods
     def relix(&block)
-      @relix ||= IndexSet.new(self)
+      @relix ||= IndexSet.new(self, Relix.redis)
       if block_given?
         @relix.instance_eval(&block)
       else
@@ -34,4 +34,10 @@ module Relix
   def index!
     relix.index!(self)
   end
-end
+
+  def deindex!
+    relix.deindex!(self)
+  end
+
+  class Error < StandardError; end
+end

data/lib/relix/index.rb

@@ -1,11 +1,24 @@
 module Relix
   class Index
-    def initialize(name, accessor, options={})
-      @name = "#{self.class.name}:#{name}"
+    def self.kind
+      @kind ||= name.gsub(/(?:^.+::|Index$)/, '').gsub(/([a-z])([A-Z])/){"#{$1}_#{$2}"}.downcase
+    end
+
+    def self.compact_kind
+      @compact_kind ||= kind[0..0]
+    end
+
+    def initialize(set, base_name, accessor, options={})
+      @set = set
+      @base_name = base_name
       @accessor = [accessor].flatten.collect{|a| a.to_s}
       @options = options
     end
 
+    def name
+      @set.keyer.index(self, @base_name)
+    end
+
     def read(object)
       @accessor.inject({}){|h,e| h[e] = object.send(e); h}
     end
@@ -25,7 +38,7 @@ module Relix
         if value_hash.include?(k)
           value_hash[k].to_s
         else
-          raise MissingIndexValueError, "Missing #{k} when looking up by #{@name}"
+          raise MissingIndexValueError, "Missing #{k} when looking up by #{name}"
         end
       end.join(":")
     end
@@ -42,10 +55,6 @@ module Relix
       nil
     end
 
-    def key_for(value)
-      "#{@name}:#{value}"
-    end
-
     module Ordering
       def initialize(*args)
         super
@@ -74,10 +83,10 @@ module Relix
         end
       end
 
-      def range_from_options(options, value=nil)
+      def range_from_options(r, options, value=nil)
         start = (options[:offset] || 0)
         if f = options[:from]
-          start = (position(f, value) + 1)
+          start = (position(r, f, value) + 1)
         end
         stop = (options[:limit] ? (start + options[:limit] - 1) : -1)
         [start, stop]
@@ -85,6 +94,6 @@ module Relix
     end
   end
 
-  class UnorderableValueError < StandardError; end
-  class MissingIndexValueError < StandardError; end
+  class UnorderableValueError < Relix::Error; end
+  class MissingIndexValueError < Relix::Error; end
 end

data/lib/relix/index_set.rb

@@ -1,15 +1,37 @@
 module Relix
   class IndexSet
-    def initialize(klass)
+    attr_accessor :redis
+    def initialize(klass, redis)
       @klass = klass
+      @redis = redis
       @indexes = Hash.new
+      @keyer = Keyer.default_for(@klass)
     end
 
     def primary_key(accessor)
-      add_index(:primary_key, 'primary_key', on: accessor)
+      @primary_key_index = add_index(:primary_key, accessor)
     end
     alias pk primary_key
 
+    def primary_key_index
+      unless @primary_key_index
+        if parent
+          @primary_key_index = parent.primary_key_index
+        else
+          raise MissingPrimaryKeyError.new("You must declare a primary key for #{@klass.name}")
+        end
+      end
+      @primary_key_index
+    end
+
+    def keyer(value=nil, options={})
+      if value
+        @keyer = value.new(@klass, options)
+      else
+        @keyer
+      end
+    end
+
     def method_missing(m, *args)
       if Relix.index_types.keys.include?(m.to_sym)
         add_index(m, *args)
@@ -20,7 +42,7 @@ module Relix
 
     def add_index(index_type, name, options={})
       accessor = (options.delete(:on) || name)
-      @indexes[name.to_s] = Relix.index_types[index_type].new(key_prefix(name), accessor, options)
+      @indexes[name.to_s] = Relix.index_types[index_type].new(self, name, accessor, options)
     end
 
     def indexes
@@ -28,56 +50,65 @@ module Relix
     end
 
     def lookup(&block)
-      unless primary_key = indexes['primary_key']
-        raise MissingPrimaryKeyError.new("You must declare a primary key for #{@klass.name}")
-      end
       if block
         query = Query.new(self)
         yield(query)
         query.run
       else
-        primary_key.all
+        primary_key_index.all(@redis)
       end
     end
 
-    def index!(object)
-      unless primary_key_index = indexes['primary_key']
-        raise MissingPrimaryKeyError.new("You must declare a primary key for #{@klass.name}")
-      end
-      pk = primary_key_index.read_normalized(object)
-      current_values_name = "#{key_prefix('current_values')}:#{pk}"
+    def index_ops(object, pk)
+      current_values_name = current_values_name(pk)
+      @redis.watch current_values_name
+      current_values = @redis.hgetall(current_values_name)
 
-      Relix.redis do |r|
-        loop do
-          r.watch current_values_name
-          current_values = r.hgetall(current_values_name)
-          indexers = []
-          indexes.each do |name,index|
-            ((watch = index.watch) && r.watch(*watch))
+      ops = indexes.collect do |name,index|
+        ((watch = index.watch) && @redis.watch(*watch))
 
-            value = index.read_normalized(object)
-            old_value = current_values[name]
+        value = index.read_normalized(object)
+        old_value = current_values[name]
 
-            next if value == old_value
-            current_values[name] = value
+        next if value == old_value
+        current_values[name] = value
 
-            next unless index.filter(r, object, value)
+        next unless index.filter(@redis, object, value)
 
-            query_value = index.query(r, value)
-            indexers << proc do
-              index.index(r, pk, object, value, old_value, *query_value)
-            end
-          end
-          r.multi do
-            indexers.each do |indexer|
-              indexer.call
-            end
-            r.hmset(current_values_name, *current_values.flatten)
-          end.each do |result|
-            raise RedisIndexingError.new(result.message) if Exception === result
-          end
-          break
+        query_value = index.query(@redis, value)
+        proc do
+          index.index(@redis, pk, object, value, old_value, *query_value)
         end
+      end.compact
+
+      ops << proc do
+        @redis.hmset(current_values_name, *current_values.flatten)
+      end
+
+      ops
+    end
+
+    def index!(object)
+      pk = primary_key_for(object)
+
+      handle_concurrent_modifications(pk) do
+        index_ops(object, pk)
+      end
+    end
+
+    def deindex!(object)
+      pk = primary_key_for(object)
+
+      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|
+          ((watch = index.watch) && @redis.watch(*watch))
+          old_value = current_values[name]
+          proc { index.deindex(@redis, pk, object, old_value) }
+        end.tap { |ops| ops << proc { @redis.del current_values_name } }
       end
     end
 
@@ -92,8 +123,42 @@ module Relix
       end
       @parent
     end
+
+    def current_values_name(pk)
+      @keyer.values(pk)
+    end
+
+  private
+
+    def handle_concurrent_modifications(primary_key)
+      retries = 5
+      loop do
+        ops = yield
+
+        results = @redis.multi do
+          ops.each do |op|
+            op.call(primary_key)
+          end
+        end
+
+        if results
+          results.each do |result|
+            raise RedisIndexingError.new(result.message) if Exception === result
+          end
+          break
+        else
+          retries -= 1
+          raise ExceededRetriesForConcurrentWritesError.new if retries <= 0
+        end
+      end
+    end
+
+    def primary_key_for(object)
+      primary_key_index.read_normalized(object)
+    end
   end
 
-  class MissingPrimaryKeyError < StandardError; end
-  class RedisIndexingError < StandardError; end
-end
+  class MissingPrimaryKeyError < Relix::Error; end
+  class RedisIndexingError < Relix::Error; end
+  class ExceededRetriesForConcurrentWritesError < Relix::Error; end
+end

data/lib/relix/indexes/multi.rb

@@ -7,15 +7,23 @@ module Relix
       r.zrem(key_for(old_value), pk)
     end
 
-    def eq(value, options={})
-      Relix.redis.zrange(key_for(value), *range_from_options(options, value))
+    def deindex(r, pk, object, old_value)
+      r.zrem(key_for(old_value), pk)
+    end
+
+    def eq(r, value, options={})
+      r.zrange(key_for(value), *range_from_options(r, options, value))
     end
 
-    def position(pk, value)
-      position = Relix.redis.zrank(key_for(value), pk)
+    def position(r, pk, value)
+      position = r.zrank(key_for(value), pk)
       raise MissingIndexValueError, "Cannot find key #{pk} in index for #{value}" unless position
       position
     end
+
+    def key_for(value)
+      @set.keyer.component(name, value)
+    end
   end
-  register_index :multi, MultiIndex
+  register_index MultiIndex
 end

data/lib/relix/indexes/primary_key.rb

@@ -3,28 +3,32 @@ module Relix
     include Ordering
 
     def watch
-      @name
+      name
     end
 
     def filter(r, object, value)
-      !r.zrank(@name, value)
+      !r.zrank(name, value)
     end
 
     def query(r, value)
-      r.zcard(@name)
+      r.zcard(name)
     end
 
     def index(r, pk, object, value, old_value, rank)
-      r.zadd(@name, rank, pk)
+      r.zadd(name, rank, pk)
     end
 
-    def all(options={})
-      Relix.redis.zrange(@name, *range_from_options(options))
+    def deindex(r, pk, object, old_value)
+      r.zrem(name, pk)
     end
 
-    def eq(value, options)
+    def all(r, options={})
+      r.zrange(name, *range_from_options(r, options))
+    end
+
+    def eq(r, value, options)
       [value]
     end
   end
-  register_index :primary_key, PrimaryKeyIndex
+  register_index PrimaryKeyIndex
 end

data/lib/relix/indexes/unique.rb

@@ -2,44 +2,51 @@ module Relix
   class UniqueIndex < Index
     include Ordering
 
-    def initialize(*args)
-      super
-      @sorted_set_name = "#{@name}:zset"
-      @hash_name = "#{@name}:hash"
+    def sorted_set_name
+      @set.keyer.component(name, 'ordering')
+    end
+
+    def hash_name
+      @set.keyer.component(name, 'lookup')
     end
 
     def watch
-      @hash_name
+      hash_name
     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}")
+      if r.hexists(hash_name, value)
+        raise NotUniqueError.new("'#{value}' is not unique in index #{name}")
       end
       true
     end
 
     def index(r, pk, object, value, old_value)
       if read(object).values.all?{|e| !e.nil?}
-        r.hset(@hash_name, value, pk)
-        r.zadd(@sorted_set_name, score(object, value), pk)
+        r.hset(hash_name, value, pk)
+        r.zadd(sorted_set_name, score(object, value), pk)
       else
-        r.hdel(@hash_name, value)
-        r.zrem(@sorted_set_name, pk)
+        r.hdel(hash_name, value)
+        r.zrem(sorted_set_name, pk)
       end
-      r.hdel(@hash_name, old_value)
+      r.hdel(hash_name, old_value)
+    end
+
+    def deindex(r, pk, object, old_value)
+      r.hdel(hash_name, old_value)
+      r.zrem(sorted_set_name, pk)
     end
 
-    def all(options={})
-      Relix.redis.zrange(@sorted_set_name, *range_from_options(options))
+    def all(r, options={})
+      r.zrange(sorted_set_name, *range_from_options(r, options))
     end
 
-    def eq(value, options={})
-      [Relix.redis.hget(@hash_name, value)].compact
+    def eq(r, value, options={})
+      [r.hget(hash_name, value)].compact
     end
   end
-  register_index :unique, UniqueIndex
+  register_index UniqueIndex
 
-  class NotUniqueError < StandardError; end
+  class NotUniqueError < Relix::Error; end
 end

data/lib/relix/query.rb

@@ -8,19 +8,20 @@ module Relix
     def [](index_name)
       index = @model.indexes[index_name.to_s]
       raise MissingIndexError.new("No index declared for #{index_name}") unless index
-      @clause = Clause.new(index)
+      @clause = Clause.new(@model.redis, index)
     end
 
     def run
       if @clause
         @clause.lookup
       else
-        @model.indexes['primary_key'].lookup
+        @model.primary_key_index.lookup
       end
     end
 
     class Clause
-      def initialize(index)
+      def initialize(redis, index)
+        @redis = redis
         @index = index
         @options = {}
       end
@@ -39,13 +40,13 @@ module Relix
         if @options[:limit] == 0
           []
         elsif @all
-          @index.all(@options)
+          @index.all(@redis, @options)
         else
-          @index.eq(@value, @options)
+          @index.eq(@redis, @value, @options)
         end
       end
     end
   end
 
-  class MissingIndexError < StandardError; end
+  class MissingIndexError < Relix::Error; end
 end

data/lib/relix/redis.rb

@@ -4,8 +4,7 @@ require 'redis'
 module Relix
   def self.redis
     unless @redis
-      @redis = ::Redis.new(host: @redis_host, port: @redis_port)
-      @redis.select @redis_db if @redis_db
+      @redis = new_redis_client
     end
     if block_given?
       yield(@redis)
@@ -14,6 +13,12 @@ module Relix
     end
   end
 
+  def self.new_redis_client
+    ::Redis.new(host: @redis_host, port: @redis_port).tap do |client|
+      client.select @redis_db if @redis_db
+    end
+  end
+
   def self.host=(value)
     @redis_host = value
   end

data/lib/relix/version.rb

@@ -1,3 +1,3 @@
 module Relix
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: relix
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-04 00:00:00.000000000Z
+date: 2012-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: &70309856251460 !ruby/object:Gem::Requirement
+  requirement: &70209042647380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.4.1
   type: :runtime
   prerelease: false
-  version_requirements: *70309856251460
+  version_requirements: *70209042647380
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70309856249460 !ruby/object:Gem::Requirement
+  requirement: &70209042646920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: 2.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *70309856249460
+  version_requirements: *70209042646920
 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
@@ -67,6 +67,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 2795857590381463961
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: