redisted 0.0.1

data/lib/redisted/index.rb

@@ -0,0 +1,330 @@
+#
+#
+# Uniqueness Index:
+#
+#     index :test_int, unique: true
+#         >> An index named "test_int" that verifies that "test_int" is always unique.
+#     index :ti, unique: :test_int
+#         >> An index named "ti" that verifies that "test_int" is always unique.
+#     index :idxkey, unique: [:test_int,:provider]
+#         >> An index named "idxkey" that verifies that the "test_int"/"provider" pair is always unique.
+#
+# Filter/Sort Index:
+#
+#     index :odd,includes: ->(elem){(elem.test_int%2)!=0}
+#         >> An index named "odd" that contains reference to objects who's test_int values are odd numbers.
+#     index :asc,order: ->(elem){elem.test_int},fields: :test_int
+#         >> An index named "asc" that contains references to *all* objects, sorted by test_int. (only recalculate when :test_int changes)
+#     index :sortedodd,includes: ->(elem){(elem.test_int%2)!=0}, order: ->(elem){elem.test_int}
+#         >> An index named "sortedodd" that contains reference to objects who's test_int values are odd numbers, sorted by test_int
+#     index :provider, match: ->(elem){(elem.provider)}
+#         >> Create multiple indices, one for each unique value returned by the match proc. Used for filtering.
+#
+#
+module Redisted
+  class Base
+    private
+    def init_indexes
+    end
+    public
+    #
+    #
+    # Setup
+    #
+    #
+    def indices
+      self.class.indices
+    end
+    class << self
+      def indices= val
+        @indices=val
+      end
+      def indices
+        @indices||={}
+        @indices
+      end
+      def index name,params
+        raise InvalidIndex,"Index redefined: #{name}" if indices[name]
+        entry={
+            redis_key: "#{prefix}[#{name}]",
+            optimistic_retry: params[:optimistic_retry],
+        }
+        if params[:unique]
+          entry[:unique_index]=true
+          entry[:fields]= if params[:unique].is_a? Array
+                            params[:unique]
+                          elsif params[:unique].is_a? Symbol
+                            [params[:unique]]
+                          else
+                            [name]
+                          end
+        else
+          entry[:unique_index]=false
+          entry[:includes]=lambdafi_index(params[:includes],true)
+          entry[:order]=lambdafi_index(params[:order],1)
+          entry[:match]=lambdafi_index(params[:match],"") if params[:match]
+          entry[:fields]= if params[:fields].nil?
+                            nil
+                          elsif params[:fields].is_a? Array
+                            params[:fields]
+                          elsif params[:fields].is_a? Symbol
+                            [params[:fields]]
+                          else
+                            nil
+                          end
+        end
+        indices[name]=entry
+      end
+      def lambdafi_index options,default_value
+        lambda do |*args|
+          ret=nil
+          if options.nil?
+            ret=default_value
+          elsif options.respond_to? :call
+            ret=options.call(*args)
+          elsif options.is_a? Symbol
+            ret=args[0].send(options,*args)
+          else
+            ret=options # An integer or other constant value...
+          end
+          ret
+        end
+      end
+    end
+
+    private
+
+    #
+    #
+    # Process Index:
+    #
+    # data is a hash of name/value pairs of fields that are going to be changed. The
+    # key is the field name, and the value is the *new*, to be assigned, value of the
+    # field (not the current value).
+    # If the old value is needed, it must be pulled from @attributes_old. If it isn't
+    # in @attributes_old, then it must be read from Redis *before* proc.call is made.
+    # proc.call should make *set redis calls to update the proper redis keys to implement
+    # the desired results. It *cannot* make *get redis calls or any other redis calls that
+    # require a return value to be correct (this is because this is executed within a multi).
+    # Additionally, @attributes_value must be updated to the new value in this call.
+    #
+    #
+    # TODO: Needs repeat logic for optimistic locking...
+    def index_process data,&proc
+      state={data: data}
+      names=[]
+      data.each do |name,value|
+        names<<name
+      end
+      state[:attr_names]=names
+      u=uniq_index_start state
+      i=index_start state
+      @watch_list=[]
+      u=uniq_index_watch_setup u
+      i=index_watch_setup i
+      begin
+        if @watch_list.size>0
+          @redis.unwatch
+          @redis.watch *@watch_list
+        end
+        u=uniq_index_verify u
+        i=index_verify i
+        @redis.multi
+        begin
+          u=uniq_index_multi_start u
+          i=index_multi_start i
+          proc.call
+          u=uniq_index_multi_end u
+          i=index_multi_end i
+          @redis.exec
+        rescue Exception
+          @redis.discard
+          raise
+        end
+      rescue Exception
+        @redis.unwatch if @watch_list.size>0
+        raise
+      end
+    end
+
+    #
+    #
+    #
+    # Unique Index
+    #
+    #
+    # Creates Key:
+    #
+    #   SET: model[index_name]
+    #
+    # Contains all id values from all instances of this model, and is used to verify uniqueness.
+    # Maintained during set_attr/save.
+    #
+    #
+    #
+    def uniq_index_start state
+      state
+    end
+    def uniq_index_watch_setup state
+      # Begin optimistic locking for all indices that are impacted by these changes...
+      indices.each do |name,index|
+        next if !index[:unique_index]
+        next if (index[:fields] & state[:attr_names]).size==0
+        @watch_list << index[:redis_key]
+      end
+      state
+    end
+
+    def uniq_index_verify state
+      indices.each do |idxname,index|
+        next if !index[:unique_index]
+        index[:fields].each do |fieldname|
+          # if we don't have it, we need to get it now...directly from redis
+          if @attributes_old_status[fieldname]!=:cached
+            @attributes_old[fieldname]=to_attr_type fieldname,@redis.hget("#{prefix}:#{@id}",fieldname)
+            @attributes_old_status[fieldname]=:cached
+          end
+        end
+      end
+
+      cmds_to_do={}
+      indices.each do |name,index|
+        next if !index[:unique_index]
+        next if (index[:fields] & state[:attr_names]).size==0
+        # Need to get the old and new index value...
+        old=unique_index_value(@attributes_old,index[:fields])
+        new=unique_index_value(@attributes_value.merge(state[:data]),index[:fields])
+        next if old==new
+        cmds_to_do[index[:redis_key]]||={old_vals: [],new_vals: []}
+        cmds_to_do[index[:redis_key]][:old_vals] << old if !old.nil?
+        cmds_to_do[index[:redis_key]][:new_vals] << new if !new.nil?
+      end
+
+      #
+      # Verify no value in the "new" list that is not in the "old" list actually exists in the index...
+      #
+      cmds_to_do.each do |redis_key,cmds|
+        (cmds[:new_vals]-cmds[:old_vals]).each do |chk_val|
+          raise ValueNotUnique, "Value #{chk_val} is not unique" if @redis.sismember(redis_key,chk_val)
+        end
+      end
+
+      state[:cmds_to_do]=cmds_to_do
+      state
+    end
+    def uniq_index_multi_start state
+      state
+    end
+    def uniq_index_multi_end state
+      state[:cmds_to_do].each do |redis_key,cmds|
+        @redis.srem(redis_key,*cmds[:old_vals]) if cmds[:old_vals].size>0
+        @redis.sadd(redis_key,*cmds[:new_vals]) if cmds[:new_vals].size>0
+      end
+      state
+    end
+    def unique_index_value vals,fields
+      ret=[]
+      fields.each do |field|
+        return nil if vals[field].nil? # If any value is nil, then the whole index is nil...
+        ret<<to_redis_type(field,vals[field]) # TODO: Take out ':','%' from the string...encode them instead...
+      end
+      ret.join(':')
+    end
+
+    #
+    #
+    #
+    # Filter/Sort Index
+    #
+    #
+    # Creates Key:
+    #
+    #   SORTED SET: model[index_name]
+    #
+    # Contains all id values from instances of this model where the ":includes" proc returns true.
+    # If no ":includes" proc is given, then all instances are included. The score for all entries
+    # is the value returned by the ":order" proc. If that proc is not specified, then the score
+    # will all be 1.
+    #
+    #
+    #
+    def index_start state
+      state
+    end
+    def index_watch_setup state
+      indices.each do |name,index|
+        next if index[:unique_index]
+        next if (!index[:fields].nil?) and ((index[:fields] & state[:attr_names]).size==0)
+        @watch_list << index[:redis_key]
+      end
+      attr_old={}
+      attr_old_status={}
+      indices.each do |name,index|
+        next if index[:unique_index]
+        # See if we have a "match" field...if so, we need to cache the old values
+        if index[:match]
+          index[:fields].each do |fieldname|
+            # if we don't have it, we need to get it now...directly from redis
+            if attr_old_status[fieldname]!=:cached
+              attr_old[fieldname]=to_attr_type fieldname,@redis.hget("#{prefix}:#{@id}",fieldname)
+              attr_old_status[fieldname]=:cached
+            end
+          end
+        end
+      end
+      state[:attributes_old]=attr_old
+      state[:attributes_old_status]=attr_old_status
+      state
+    end
+
+    def index_verify state
+      state
+    end
+    def index_multi_start state
+      state
+    end
+    def index_multi_end state
+      indices.each do |name,index|
+        next if index[:unique_index]
+        next if (!index[:fields].nil?) and ((index[:fields] & state[:attr_names]).size==0)
+
+        if index[:match].nil?
+          if index[:includes].call(self)
+            @redis.zadd index[:redis_key],index[:order].call(self),self.id
+          else
+            @redis.zrem index[:redis_key],self.id
+          end
+        else
+          old=self.dup
+          old.internal_only_force_update_attributes(state[:attributes_old],state[:attributes_old_status])
+          old_match_val=index[:match].call(old)
+          new_match_val=index[:match].call(self)
+
+
+          if !old_match_val.nil? and old_match_val!=""
+            @redis.zrem "#{index[:redis_key]}:#{old_match_val}",self.id
+          end
+          if !new_match_val.nil? and new_match_val!=""
+            if index[:includes].call(self)
+              @redis.zadd "#{index[:redis_key]}:#{new_match_val}",index[:order].call(self),self.id
+            end
+          end
+
+
+
+
+        end
+
+
+      end
+      state
+    end
+
+    public # Unfortunately, this must be public, even though it should never be called externally
+    def internal_only_force_update_attributes attr,status
+      @attributes_value=attr
+      @attributes_status=status
+    end
+
+  end
+end

data/lib/redisted/instantiate.rb

@@ -0,0 +1,34 @@
+module Redisted
+  class Base
+    class << self
+      #
+      # Use
+      #
+      def create attrs=nil,redis=nil
+        ret=new attrs,redis
+        ret.save
+        ret
+      end
+      def find ids
+        if ids.is_a? Array
+          ret=[]
+          ids.each do |id|
+            m=new
+            m.load id
+            ret << m
+          end
+          ret
+        else
+          m=new
+          m.load ids
+          m
+        end
+      end
+    end
+    def load id
+      @id=id
+      pre_cache_values if get_obj_option(:pre_cache_all) and get_obj_option(:pre_cache_all)[:when]==:create
+      self
+    end
+  end
+end

data/lib/redisted/references.rb

@@ -0,0 +1,105 @@
+module Redisted
+  class Base
+    def references
+      self.class.references
+    end
+    class << self
+      def references= val
+        @references=val
+      end
+      def references
+        @references||={}
+        @references
+      end
+    end
+    private
+    def init_references
+    end
+
+    def get_reference ref,details
+      ret=nil
+      # TODO: Can this be cached???
+      if details[:ref_type]==:one
+        id=get_attr("#{details[:string]}_id".to_sym)
+        ret=details[:class].find(id)
+      elsif details[:ref_type]==:many
+        if details[:model_type]==:redisted
+          ret=details[:class].scoped
+          ret.internal_add_reference "#{prefix}[#{details[:string]}_id]"
+        else
+          return [] if @redis.exists "#{prefix}#[{details[:string]}_id]"
+          id_list=@redis.zrange "#{prefix}[#{details[:string]}_id]",0,-1
+          ret=details[:class].find(id_list)
+        end
+      end
+      ret
+    end
+    def set_reference ref,details,val
+      if details[:ref_type]==:one
+        set_attr "#{details[:string]}_id".to_sym,val.id.to_s
+      elsif details[:ref_type]==:many
+        raise "LEELEE: Not implemented yet"
+      end
+      nil
+    end
+    class << self
+      public
+
+
+
+      #
+      # Setup
+      #
+      def references_one sym,opt={}
+        details=name_to_class_details sym,opt[:as]
+        raise InvalidReference,"Reference already defined" if !references[details[:symbol]].nil?
+        field "#{details[:string]}_id".to_sym
+        details[:ref_type]=:one
+        references[details[:symbol]]=details
+      end
+      def references_many sym,opt={}
+        details=name_to_class_details sym,opt[:as]
+        raise InvalidReference,"Reference already defined" if !references[details[:plural][:symbol]].nil?
+        field "#{details[:plural][:string]}_list".to_sym
+        details[:ref_type]=:many
+        references[details[:plural][:symbol]]=details
+      end
+
+      private
+
+      def name_to_class_details obj,alt_name
+        if alt_name
+          ret={
+            symbol: alt_name.to_sym,
+            string: alt_name.to_s,
+            plural:{
+              symbol: alt_name.to_sym,
+              string: alt_name.to_s,
+            }
+          }
+        else
+          ret={
+            symbol: obj.to_sym,
+            string: obj.to_s,
+            plural:{
+              symbol: obj.to_s.pluralize.to_sym,
+              string: obj.to_s.pluralize
+            }
+          }
+        end
+        ret[:class]=if obj.kind_of? Symbol
+                      Kernel.const_get obj.to_s.capitalize
+                    else
+                      Kernel.const_get obj
+                    end
+        if ret[:class].respond_to?("is_redisted_model?") and ret[:class].is_redisted_model?
+          ret[:model_type]=:redisted
+        else
+          ret[:model_type]=:other
+        end
+        ret
+      end
+
+    end
+  end
+end

data/lib/redisted/relation.rb

@@ -0,0 +1,190 @@
+module Redisted
+  class Base
+    #
+    #
+    # Relation
+    #
+    #
+    class Relation
+      def initialize the_class,redis,scopes,indices
+        @the_class=the_class
+        @redis=redis
+        @scopes=scopes
+        @indices=indices
+        @is_in_list=[]
+      end
+      #
+      # Low Level Setup Conditions
+      #
+      def is_in index_name,*args
+        index=@indices[index_name.to_sym]
+        raise InvalidQuery,"Could not find index '#{index_name}'" if index.nil?
+        if index[:match]
+          raise InvalidQuery,"No parameter provided to index when one was expected" if args.size!=1
+        else
+          raise InvalidQuery,"Parameter provided to index when not expected" if args.size!=0
+        end
+        @is_in_list<<{:index_name=>index_name,:index=>index,:args=>args}
+        self
+      end
+      def internal_add_reference redis_key
+        @is_in_list<<{
+          :index_name=>nil,
+          :args=>nil,
+          :index=>{
+            :redis_key=>redis_key
+          }
+        }
+      end
+
+
+
+      #
+      # Calculate Results
+      #
+      def first
+        key=merge_keys @is_in_list
+        id=nil
+        if key
+          id_list=@redis.zrange key,0,-1 # LEELEE: Performance improve...
+          raise InvalidQuery,"No keys" if id_list.size==0
+          id=id_list.first
+        else
+          keyprefix="#{prefix}:"
+          key_list=@redis.keys "#{keyprefix}*"
+          raise InvalidQuery,"No keys" if key_list.size==0
+          id=id_list.first[keyprefix.size..-1]
+        end
+        obj=@the_class.new
+        obj.load id
+        obj
+      end
+      def last
+        key=merge_keys @is_in_list
+        id=nil
+        if key
+          id_list=@redis.zrange key,0,-1 # LEELEE: Performance improve...
+          raise InvalidQuery,"No keys" if id_list.size==0
+          id=id_list.last
+        else
+          keyprefix="#{prefix}:"
+          key_list=@redis.keys "#{keyprefix}*"
+          raise InvalidQuery,"No keys" if key_list.size==0
+          id=id_list.last[keyprefix.size..-1]
+        end
+        obj=@the_class.new
+        obj.load id
+        obj
+      end
+      def all
+        ret=[]
+        key=merge_keys @is_in_list
+        if key
+          id_list=@redis.zrange key,0,-1
+          id_list.each do |id|
+            obj=@the_class.new
+            obj.load id
+            ret<<obj
+          end
+        else
+          keyprefix="#{prefix}:"
+          key_list=@redis.keys "#{keyprefix}*"
+          key_list.each do |key|
+            obj=@the_class.new
+            obj.load key[keyprefix.size..-1]
+            ret<<obj
+          end
+        end
+        ret
+      end
+      def each &proc
+        key=merge_keys @is_in_list
+        if key
+          id_list=@redis.zrange key,0,-1
+          id_list.each do |id|
+            obj=@the_class.new
+            obj.load id
+            proc.call(obj)
+          end
+        else
+          keyprefix="#{prefix}:"
+          key_list=@redis.keys "#{keyprefix}*"
+          key_list.each do |key|
+            obj=@the_class.new
+            obj.load key[keyprefix.size..-1]
+            proc.call(obj)
+          end
+        end
+        nil
+      end
+      def delete_all
+        # TODO: Don't instantiate the object for delete...do it manually...
+        #self.each do |m|
+        #  m.delete
+        #end
+      end
+      def destroy_all
+        self.each do |m|
+          m.destroy
+        end
+      end
+      def method_missing(id, *args)
+        return add_one args[0] if id.to_s=="<<"
+        return @scopes[id].call(*args) if @scopes[id]
+        return is_in id[3..-1],*args if id[0,3]=="by_"
+        super
+      end
+
+      private
+      def prefix
+        @the_class.prefix
+      end
+      def merge_keys list
+        return nil if list.size==0
+        return key_name(list.first) if list.size==1
+        cnt=@redis.incr "redisted_tmp_id"
+        # TODO: Handle calculating if weights should be used...
+        tmpkey="redisted_tmp[#{cnt}]"
+        key_list=[]
+        @is_in_list.each do |index|
+          key_list<<key_name(index)
+        end
+        @redis.zinterstore tmpkey,key_list,{:aggregate=>:sum,:weight=>3}
+        @redis.expire tmpkey,3600 # TODO: Value should be configurable...
+        return tmpkey
+      end
+      def key_name index
+        ret=index[:index][:redis_key]
+        ret+=":#{index[:args][0]}" if index[:index][:match]
+        ret
+      end
+
+      #
+      #
+      # Add objects to a relation
+      #
+      #
+      def add_one val
+        @is_in_list.each do |index|
+          next if !index[:index_name].nil?
+          @redis.zadd index[:index][:redis_key],1,val.id
+        end
+      end
+
+    end
+
+    class << self
+      def scoped
+        Relation.new self,@@redis,scopes,indices
+      end
+      def method_missing(id,*args,&proc)
+        is_scoped=(id[0]=='_')
+        is_scoped||=[:first,:last,:all,:each,:delete_all,:destroy_all,:where,:limit,:offset,:order,:reverse_order].include? id.to_sym
+        is_scoped||= !scopes[id.to_sym].nil?
+        is_scoped||= (id[0,3]=="by_")
+        return scoped.send(id,*args,&proc) if is_scoped
+        super
+      end
+    end
+  end
+end

data/lib/redisted/version.rb

@@ -0,0 +1,3 @@
+module Redisted
+  VERSION = "0.0.1"
+end

data/lib/redisted.rb

@@ -0,0 +1,10 @@
+require "redisted/version"
+require "redisted/errors"
+require "redisted/base"
+require "redisted/fields"
+require "redisted/instantiate"
+require "redisted/getsetattr"
+require "redisted/index"
+require "redisted/relation"
+require "redisted/references"
+require "redisted/delete"