relix 1.0.0 → 1.0.1

data/lib/relix/core.rb

@@ -0,0 +1,37 @@
+module Relix
+  def self.included(klass)
+    super
+    klass.extend ClassMethods
+  end
+
+  def self.index_types
+    @index_types ||= {}
+  end
+
+  def self.register_index(name, index)
+    index_types[name.to_sym] = index
+  end
+
+  module ClassMethods
+    def relix(&block)
+      @relix ||= IndexSet.new(self)
+      if block_given?
+        @relix.instance_eval(&block)
+      else
+        @relix
+      end
+    end
+
+    def lookup(&block)
+      relix.lookup(&block)
+    end
+  end
+
+  def relix
+    self.class.relix
+  end
+
+  def index!
+    relix.index!(self)
+  end
+end

data/lib/relix/index.rb

@@ -0,0 +1,90 @@
+module Relix
+  class Index
+    def initialize(name, accessor, options={})
+      @name = "#{self.class.name}:#{name}"
+      @accessor = [accessor].flatten.collect{|a| a.to_s}
+      @options = options
+    end
+
+    def read(object)
+      @accessor.inject({}){|h,e| h[e] = object.send(e); h}
+    end
+
+    def read_normalized(object)
+      normalize(read(object))
+    end
+
+    def normalize(value)
+      value_hash = case value
+      when Hash
+        value.inject({}){|h, (k,v)| h[k.to_s] = v; h}
+      else
+        {@accessor.first => value}
+      end
+      @accessor.collect do |k|
+        if value_hash.include?(k)
+          value_hash[k].to_s
+        else
+          raise MissingIndexValueError, "Missing #{k} when looking up by #{@name}"
+        end
+      end.join(":")
+    end
+
+    def watch
+      nil
+    end
+
+    def filter(r, object, value)
+      true
+    end
+
+    def query(r, value)
+      nil
+    end
+
+    def key_for(value)
+      "#{@name}:#{value}"
+    end
+
+    module Ordering
+      def initialize(*args)
+        super
+        @order = @options[:order]
+      end
+
+      def score(object, value)
+        if @order
+          value = object.send(@order)
+        end
+        case value
+        when Numeric
+          value
+        when Time
+          value.to_f
+        else
+          if value.respond_to?(:to_i)
+            value.to_i
+          elsif value.respond_to?(:to_time)
+            value.to_time.to_f
+          elsif @order
+            raise UnorderableValueError.new("Unable to convert #{value} in to a number for ordering.")
+          else
+            0
+          end
+        end
+      end
+
+      def range_from_options(options, value=nil)
+        start = (options[:offset] || 0)
+        if f = options[:from]
+          start = (position(f, value) + 1)
+        end
+        stop = (options[:limit] ? (start + options[:limit] - 1) : -1)
+        [start, stop]
+      end
+    end
+  end
+
+  class UnorderableValueError < StandardError; end
+  class MissingIndexValueError < StandardError; end
+end

data/lib/relix/index_set.rb

@@ -0,0 +1,99 @@
+module Relix
+  class IndexSet
+    def initialize(klass)
+      @klass = klass
+      @indexes = Hash.new
+    end
+
+    def primary_key(accessor)
+      add_index(:primary_key, 'primary_key', on: accessor)
+    end
+    alias pk primary_key
+
+    def method_missing(m, *args)
+      if Relix.index_types.keys.include?(m.to_sym)
+        add_index(m, *args)
+      else
+        super
+      end
+    end
+
+    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)
+    end
+
+    def indexes
+      (parent ? parent.indexes.merge(@indexes) : @indexes)
+    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
+      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}"
+
+      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))
+
+            value = index.read_normalized(object)
+            old_value = current_values[name]
+
+            next if value == old_value
+            current_values[name] = value
+
+            next unless index.filter(r, 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
+        end
+      end
+    end
+
+    def key_prefix(name)
+      "#{@klass.name}:#{name}"
+    end
+
+    def parent
+      unless @parent || @parent == false
+        parent = @klass.superclass
+        @parent = (parent.respond_to?(:relix) ? parent.relix : false)
+      end
+      @parent
+    end
+  end
+
+  class MissingPrimaryKeyError < StandardError; end
+  class RedisIndexingError < StandardError; end
+end

data/lib/relix/indexes/multi.rb

@@ -0,0 +1,21 @@
+module Relix
+  class MultiIndex < Index
+    include Ordering
+
+    def index(r, pk, object, value, old_value)
+      r.zadd(key_for(value), score(object, value), pk)
+      r.zrem(key_for(old_value), pk)
+    end
+
+    def eq(value, options={})
+      Relix.redis.zrange(key_for(value), *range_from_options(options, value))
+    end
+
+    def position(pk, value)
+      position = Relix.redis.zrank(key_for(value), pk)
+      raise MissingIndexValueError, "Cannot find key #{pk} in index for #{value}" unless position
+      position
+    end
+  end
+  register_index :multi, MultiIndex
+end

data/lib/relix/indexes/primary_key.rb

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

data/lib/relix/indexes/unique.rb

@@ -0,0 +1,45 @@
+module Relix
+  class UniqueIndex < Index
+    include Ordering
+
+    def initialize(*args)
+      super
+      @sorted_set_name = "#{@name}:zset"
+      @hash_name = "#{@name}:hash"
+    end
+
+    def watch
+      @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}")
+      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)
+      else
+        r.hdel(@hash_name, value)
+        r.zrem(@sorted_set_name, pk)
+      end
+      r.hdel(@hash_name, old_value)
+    end
+
+    def all(options={})
+      Relix.redis.zrange(@sorted_set_name, *range_from_options(options))
+    end
+
+    def eq(value, options={})
+      [Relix.redis.hget(@hash_name, value)].compact
+    end
+  end
+  register_index :unique, UniqueIndex
+
+  class NotUniqueError < StandardError; end
+end

data/lib/relix/query.rb

@@ -0,0 +1,51 @@
+module Relix
+  class Query
+    def initialize(model)
+      @model = model
+      @offset = 0
+    end
+
+    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)
+    end
+
+    def run
+      if @clause
+        @clause.lookup
+      else
+        @model.indexes['primary_key'].lookup
+      end
+    end
+
+    class Clause
+      def initialize(index)
+        @index = index
+        @options = {}
+      end
+
+      def eq(value, options={})
+        @value = @index.normalize(value)
+        @options = options
+      end
+
+      def all(options={})
+        @all = true
+        @options = options
+      end
+
+      def lookup
+        if @options[:limit] == 0
+          []
+        elsif @all
+          @index.all(@options)
+        else
+          @index.eq(@value, @options)
+        end
+      end
+    end
+  end
+
+  class MissingIndexError < StandardError; end
+end

data/lib/relix/redis.rb

@@ -0,0 +1,24 @@
+require 'hiredis'
+require 'redis'
+
+module Relix
+  def self.redis
+    unless @redis
+      @redis = ::Redis.new(port: @redis_port)
+      @redis.select @redis_db if @redis_db
+    end
+    if block_given?
+      yield(@redis)
+    else
+      @redis
+    end
+  end
+
+  def self.port=(value)
+    @redis_port = value
+  end
+
+  def self.db=(value)
+    @redis_db = value
+  end
+end

data/lib/relix/version.rb

@@ -1,3 +1,3 @@
 module Relix
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: relix
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -13,18 +13,18 @@ date: 2011-11-04 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hiredis
-  requirement: &70323249027760 !ruby/object:Gem::Requirement
+  requirement: &70135708785180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.3.2
+        version: 0.4.1
   type: :runtime
   prerelease: false
-  version_requirements: *70323249027760
+  version_requirements: *70135708785180
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &70323249027180 !ruby/object:Gem::Requirement
+  requirement: &70135708783420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: 2.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *70323249027180
+  version_requirements: *70135708783420
 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
@@ -46,6 +46,14 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/relix.rb
+- lib/relix/core.rb
+- lib/relix/index.rb
+- lib/relix/indexes/multi.rb
+- lib/relix/indexes/primary_key.rb
+- lib/relix/indexes/unique.rb
+- lib/relix/index_set.rb
+- lib/relix/query.rb
+- lib/relix/redis.rb
 - lib/relix/version.rb
 homepage: http://github.com/ntalbott/relix
 licenses: []