redis_object 0.5.0 → 1.0

data/lib/redis_object/ext/triggers.rb

@@ -1,72 +1,20 @@
 module Seabright
 	module Triggers
 		
+		def set(k,v)
+			super(k,v)
+			if self.class.field_triggers[k.to_sym]
+				send(self.class.field_triggers[k.to_sym],k,v)
+			end
+			self.class.update_triggers.each do |actn|
+				send(actn.to_sym,k,v)
+			end
+		end
+		
 		module ClassMethods
 			
 			def trigger_on_set(fld,actn)
 				field_triggers[fld.to_sym] = actn.to_sym
-				intercept_sets_for_triggers!
-			end
-			
-			def intercept_sets_for_triggers!
-				return if @intercepted_sets_for_triggers
-				self.class_eval do
-					alias_method :untriggered_set, :set unless method_defined?(:untriggered_set)
-					def set(k,v)
-						untriggered_set(k,v)
-						unless self.class.untriggerables.include?(k)
-							begin
-								self.class.untriggerables << k
-								if self.class.field_triggers[k.to_sym]
-									send(self.class.field_triggers[k.to_sym],k,v)
-								end
-								self.class.update_triggers.each do |actn|
-									send(actn.to_sym,k,v)
-								end
-							ensure
-								self.class.untriggerables.delete k
-							end
-						end
-					end
-					alias_method :untriggered_setnx, :setnx unless method_defined?(:untriggered_setnx)
-					def setnx(k,v)
-						ret = untriggered_setnx(k,v)
-						unless self.class.untriggerables.include?(k)
-							begin
-								self.class.untriggerables << k
-								if self.class.field_triggers[k.to_sym]
-									send(self.class.field_triggers[k.to_sym],k,v)
-								end
-								self.class.update_triggers.each do |actn|
-									send(actn.to_sym,k,v)
-								end
-							ensure
-								self.class.untriggerables.delete k
-							end
-						end
-						ret
-					end
-					
-				end
-				@intercepted_sets_for_triggers = true
-			end
-			
-			def intercept_reference_for_triggers!
-				return if @intercepted_reference_for_triggers
-				self.class_eval do
-					alias_method :untriggered_reference, :reference unless method_defined?(:untriggered_reference)
-					def reference(obj)
-						untriggered_reference(obj)
-						self.class.reference_triggers.each do |actn|
-							send(actn.to_sym,obj)
-						end
-					end
-				end
-				@intercepted_reference_for_triggers = true
-			end
-			
-			def untriggerables
-				@untriggerables ||= [:updated_at,:created_at]
 			end
 			
 			def field_triggers
@@ -74,21 +22,11 @@ module Seabright
 			end
 			
 			def trigger_on_update(actn)
-				update_triggers << actn.to_sym
-				intercept_sets_for_triggers!
+				update_triggers.push actn.to_sym
 			end
 			
 			def update_triggers
-				@update_triggers ||= Set.new
-			end
-			
-			def trigger_on_reference(actn)
-				reference_triggers << actn.to_sym
-				intercept_reference_for_triggers!
-			end
-			
-			def reference_triggers
-				@reference_triggers ||= Set.new
+				@update_triggers ||= []
 			end
 			
 		end
@@ -98,4 +36,4 @@ module Seabright
 		end
 		
 	end
-end
+end

data/lib/redis_object/indices.rb

@@ -1,50 +1,45 @@
 module Seabright
 	module Indices
 		
+		# def save_indices
+		# 	# self.class.indices.each do |indx|
+		# 	# 	indx.each do |key,idx|
+		# 	# 		
+		# 	# 	end
+		# 	# end
+		# 	self.class.sort_indices.each do |idx|
+		# 		store.zadd(index_key(idx), send(idx).to_i, hkey)
+		# 	end
+		# end
+		
 		def index_key(idx)
 			self.class.index_key(idx)
 		end
 		
-		module ClassMethods
-			
-			def intercept_sets_for_indices!
-				return if @intercepted_sets_for_indices
-				self.class_eval do
-					alias_method :unindexed_set, :set unless method_defined?(:unindexed_set)
-					def set(k,v)
-						ret = unindexed_set(k,v)
-						if self.class.has_sort_index?(k)
-							store.zrem(index_key(k), hkey)
-							store.zadd(index_key(k), score_format(k,v), hkey)
-						end
-						ret
-					end
-					alias_method :unindexed_mset, :mset unless method_defined?(:unindexed_mset)
-					def mset(dat)
-						ret = unindexed_mset(dat)
-						dat.select {|k,v| self.class.has_sort_index?(k) }.each do |k,v|
-							store.zrem(index_key(k), hkey)
-							store.zadd(index_key(k), score_format(k,v), hkey)
-						end
-						ret
-					end
-					alias_method :unindexed_setnx, :setnx unless method_defined?(:unindexed_setnx)
-					def setnx(k,v)
-						ret = unindexed_setnx(k,v)
-						if self.class.has_sort_index?(k)
-							store.zrem(index_key(k), hkey)
-							store.zadd(index_key(k), score_format(k,v), hkey)
-						end
-						ret
-					end
-					
-				end
-				@intercepted_sets_for_indices = true
+		# def save
+		# 	super
+		# 	save_indices
+		# end
+		
+		def mset(dat)
+			super(dat)
+			dat.select {|k,v| self.class.has_sort_index?(k) }.each do |k,v|
+				store.zadd(index_key(k), score_format(k,v), hkey)
 			end
+		end
+		
+		def set(k,v)
+			super(k,v)
+			if self.class.has_sort_index?(k)
+				store.zadd(index_key(k), score_format(k,v), hkey)
+			end
+		end
+		
+		module ClassMethods
 			
 			def indexed(idx,num=-1,reverse=false)
 				out = Enumerator.new do |yielder|
-					store.send(reverse ? :zrevrange : :zrange, index_key(idx), 0, num-1).each do |member|
+					store.send(reverse ? :zrevrange : :zrange, index_key(idx), 0, num).each do |member|
 						if a = self.find_by_key(member)
 							yielder << a
 						end
@@ -63,20 +58,20 @@ module Seabright
 				"#{self.plname}::#{idx}"
 			end
 			
+			# def index(opts)
+			# 	indices << opts
+			# end
+			# 
+			# def indices
+			# 	@@indices ||= []
+			# end
+			
 			def sort_indices
 				@@sort_indices ||= []
 			end
 			
 			def sort_by(k)
 				sort_indices << k.to_sym
-				intercept_sets_for_indices!
-			end
-			
-			def reindex(k)
-				store.del index_key(k)
-				all.each do |obj|
-					obj.set(k,obj.get(k))
-				end
 			end
 			
 			def has_sort_index?(k)

data/lib/redis_object/keys.rb

@@ -15,15 +15,15 @@ module Seabright
 		
 		module ClassMethods
 			
-			def key(ident=nil)
-				"#{cname}#{ident ? ":#{ident.gsub(/^.*:/,'')}" : ""}"
+			def key(ident)
+				"#{cname}:#{ident.gsub(/^.*:/,'')}"
 			end
 			
-			def reserve_key(ident=nil)
+			def reserve_key(ident)
 				"#{key(ident)}_reserve"
 			end
 			
-			def hkey(ident = nil)
+			def hkey(ident = id)
 				"#{key(ident)}_h"
 			end
 			

data/lib/redis_object/storage.rb

@@ -19,12 +19,8 @@ module Seabright
 				adapters[id] ||= const_get(adapter).new(config(id))
 			end
 			
-			def configure_store(conf,id=store_name,*ids)
+			def configure_store(conf,id=store_name)
 				configs[id] = conf
-				ids.each do |i|
-					configs[i] = conf
-				end
-				store(id)
 			end
 			
 			def use_store(id)
@@ -58,31 +54,6 @@ module Seabright
 				configs[id]
 			end
 			
-			def stores
-				adapters
-			end
-			
-			def dump_stores_to_files(path)
-				raise "Directory does not exist!" unless Dir.exists?(File.dirname(path))
-				adapters.each do |name,adptr|
-					if adptr.respond_to? :dump_to_file
-						puts "Dumping #{name} into #{path}/#{name.to_s}.dump"
-						adptr.dump_to_file("#{path}/#{name.to_s}.dump")
-					end
-				end
-			end
-			
-			def restore_stores_from_files(path)
-				raise "Directory does not exist!" unless Dir.exists?(File.dirname(path))
-				Dir.glob(path + "/*.dump").each do |file|
-					name = file.gsub(/\.[^\.]+$/,'').gsub(/.*\//,'').to_sym
-					if (stor = store(name)) && stor.respond_to?(:restore_from_file)
-						puts "Restoring #{name} from #{file}"
-						stor.restore_from_file(file)
-					end
-				end
-			end
-			
 		end
 		
 		def self.included(base)

data/lib/redis_object/storage/adapter.rb

@@ -23,18 +23,15 @@ module Seabright
 			end
 			
 			def reset
-				connections.each_index do |i|
-					connections[i] = nil
+				@connections.each_index do |i|
+					@connections[i] = nil
 				end
 			end
 			alias_method :reconnect!, :reset
 			
 			def connection(num=0)
-				connections[num] ||= new_connection
-			end
-			
-			def connections
 				@connections ||= []
+				@connections[num] ||= new_connection
 			end
 			
 			def new_connection

data/lib/redis_object/storage/redis.rb

@@ -3,7 +3,6 @@ module Seabright
 		class Redis < Adapter
 			
 			def method_missing(sym, *args, &block)
-				return super unless connection.respond_to?(sym)
 				puts "[Storage::Redis] #{sym}(#{args.inspect.gsub(/\[|\]/m,'')})" if Debug.verbose?
 				begin
 					connection.send(sym,*args, &block)
@@ -11,109 +10,15 @@ module Seabright
 					puts "Rescued: #{err.inspect}" if DEBUG
 					reset
 					connection.send(sym,*args, &block)
-				rescue ::Redis::TimeoutError => err
-					puts "Rescued connection timeout: #{err.inspect}" if DEBUG
-					reset
-					connection.send(sym,*args, &block)
 				end
 			end
 			
 			def new_connection
 				require 'redis'
-				puts "Connecting to Redis with: #{config_opts(:path, :db, :password, :host, :port, :timeout, :tcp_keepalive).inspect}" if DEBUG
-				::Redis.new(config_opts(:path, :db, :password, :host, :port, :timeout, :tcp_keepalive))
-			end
-			
-			DUMP_SEPARATOR = "---:::RedisObject::DUMP_SEPARATOR:::---"
-			REC_SEPARATOR = "---:::RedisObject::REC_SEPARATOR:::---"
-			
-			def dump_to_file(file)
-				File.open(file,'wb') do |f|
-					keys = connection.send(:keys,"*")
-					f.write keys.map {|k|
-						v = connection.dump(k)
-						v.force_encoding(Encoding::BINARY)
-						[k,v].join(DUMP_SEPARATOR)
-					}.join(REC_SEPARATOR)
-				end
-			end
-			
-			def restore_from_file(file)
-				str = File.read(file)
-				str.force_encoding(Encoding::BINARY)
-				str.split(REC_SEPARATOR).each do |line|
-					line.force_encoding(Encoding::BINARY)
-					key, val = line.split(DUMP_SEPARATOR)
-					connection.multi do
-						connection.del key
-						connection.restore key, 0, val
-					end
-				end
-			end
-
-			def rename_class old_name, new_name
-				old_name = old_name.to_s#.split('::').last
-				new_name = new_name.to_s#.split('::').last
-				old_collection_name = old_name.split('::').last.underscore.pluralize
-				new_collection_name = new_name.split('::').last.underscore.pluralize
-
-				# references to type in collection data
-				keys("#{old_name}:*:backreferences").each do |backref_key|
-					smembers(backref_key).each do |hashref|
-						# there are two referenes we need to fix: individual references to items
-						# and lists of collection names.
-						#
-						# this updates the item references in collections
-						backref = hashref.sub(/_h$/,'');
-						old_collection = "#{backref}:COLLECTION:#{old_collection_name}"
-						new_collection = "#{backref}:COLLECTION:#{new_collection_name}"
-						zrange(old_collection, 0, 99999, withscores:true).each do |key, score|
-							zadd(new_collection, score, key.sub(/^#{old_name}/, new_name))
-						end
-						del(old_collection)
-
-						# this updates the lists of collection names
-						collection_names = "#{hashref}:collections"
-						smembers(collection_names).each do |collection_name|
-							if collection_name == old_collection_name
-								sadd(collection_names, new_collection_name)
-								srem(collection_names, old_collection_name)
-							end
-						end
-					end
-					rename(backref_key, backref_key.sub(/^#{old_name}/, new_name))
-				end
-
-				# type-wide id index
-				smembers(old_name.pluralize).each do |key|
-					sadd(new_name.pluralize, key.sub(/^#{old_name}/, new_name))
-					old_class = hget("#{key}_h", :class)
-					old_key = hget("#{key}_h", :key)
-					hset("#{key}_h", :class, old_class.sub(/#{old_name}$/, new_name))
-					hset("#{key}_h", :key, old_key.sub(/^#{old_name}/, new_name))
-					hset("#{key}_h", "#{new_name.downcase}_id", key.sub(/^#{old_name}:/,''))
-					hdel("#{key}_h", "#{old_name.downcase}_id")
-				end
-				del(old_name.pluralize)
-
-				# column indexes
-				keys("#{old_name.pluralize}::*").each do |old_index|
-					new_index = old_index.sub(/^#{old_name.pluralize}/, new_name.pluralize)
-					zrange(old_index, 0, 99999, withscores:true).each do |key, score|
-						zadd(new_index, score, key.sub(/^#{old_name}/, new_name))
-					end
-					del(old_index)
-				end
-
-				# top-level keys
-				keys("#{old_name}:*").each do |key|
-					rename(key, key.sub(/^#{old_name}/, new_name))
-				end
-				keys("#{old_name.pluralize}:*").each do |key|
-					rename(key, key.sub(/^#{old_name.pluralize}/, new_name.pluralize))
-				end
+				# puts "Connecting to Redis with: #{config_opts(:path, :db, :password).inspect}" if DEBUG
+				::Redis.new(config_opts(:path, :db, :password))
 			end
 			
 		end
 	end
-end
+end

data/lib/redis_object/timestamps.rb

@@ -2,54 +2,34 @@ module Seabright
 	module Timestamps
 		
 		def update_timestamps
-			# return unless self.class.time_matters?
+			return if @@time_irrelevant
 			set(:created_at, Time.now) if !is_set?(:created_at)
 			set(:updated_at, Time.now)
 		end
 		
+		def mset(dat)
+			super(dat)
+			set(:updated_at, Time.now)
+		end
+		
+		def set(k,v)
+			super(k,v)
+			set(:updated_at, Time.now) unless k.to_sym == :updated_at
+		end
+		
+		def save
+			super
+			update_timestamps
+		end
+		
 		module ClassMethods
 			
-			def intercept_sets_for_timestamps!
-				return if @intercepted_sets_for_timestamps
-				self.class_eval do
-					alias_method :untimestamped_set, :set unless method_defined?(:untimestamped_set)
-					def set(k,v)
-						ret = untimestamped_set(k,v)
-						set(:updated_at, Time.now) unless k.to_sym == :updated_at
-						ret
-					end
-					alias_method :untimestamped_mset, :mset unless method_defined?(:untimestamped_mset)
-					def mset(dat)
-						ret = untimestamped_mset(dat)
-						set(:updated_at, Time.now)
-						ret
-					end
-					alias_method :untimestamped_setnx, :setnx unless method_defined?(:untimestamped_setnx)
-					def setnx(k,v)
-						ret = untimestamped_setnx(k,v)
-						set(:updated_at, Time.now) unless k.to_sym == :updated_at
-						ret
-					end
-					alias_method :untimestamped_save, :save unless method_defined?(:untimestamped_save)
-					def save
-						ret = untimestamped_save()
-						update_timestamps
-						ret
-					end
-				end
-				@intercepted_sets_for_timestamps = true
+			def time_matters_not!
+				@@time_irrelevant = true
+				@@sort_indices.delete(:created_at)
+				@@sort_indices.delete(:updated_at)
 			end
 			
-			# def time_matters?
-			# 	@time_irrelevant != true
-			# end
-			# 
-			# def time_matters_not!
-			# 	@time_irrelevant = true
-			# 	sort_indices.delete(:created_at)
-			# 	sort_indices.delete(:updated_at)
-			# end
-			# 
 			def recently_created(num=5)
 				self.indexed(:created_at,num,true)
 			end
@@ -61,13 +41,12 @@ module Seabright
 		end
 		
 		def self.included(base)
-			# @time_irrelevant = false
+			@@time_irrelevant = false
 			base.send(:sort_by,:created_at)
 			base.send(:sort_by,:updated_at)
 			base.send(:register_format,:created_at, :date)
 			base.send(:register_format,:updated_at, :date)
 			base.extend(ClassMethods)
-			base.intercept_sets_for_timestamps!
 		end
 		
 	end