redis_object 0.5.0 → 1.0

data/lib/redis_object/collection.rb

@@ -2,6 +2,20 @@ module Seabright
 	
 	module Collections
 		
+		def dump
+			require "utf8_utils"
+			out = ["puts \"Creating: #{id}\""]
+			s_id = id.gsub(/\W/,"_")
+			out << "a#{s_id} = #{self.class.cname}.new(#{actual.to_s.tidy_bytes})"
+			collections.each do |col|
+				col.each do |sobj|
+					out << sobj.dump(self)
+				end
+			end
+			out << "a#{s_id}.save"
+			out.join("\n")
+		end
+		
 		def hkey_col(ident = nil)
 			"#{hkey}:collections"
 		end
@@ -10,24 +24,49 @@ module Seabright
 			super(o_id)
 			store.smembers(hkey_col).each do |name|
 				collections[name] = Seabright::Collection.load(name,self)
-				define_access(name) do
-					get_collection(name)
-				end
-				define_access(name.to_s.singularize) do
-					get_collection(name).latest
-				end
 			end
+			# TODO: Here's an example of dynamic method creation - should do this instead of method_missing + module intercepts...
+			# %w[report alert error summary].each do |kind|
+			# 	      class_eval <<-END
+			# 	        if "#{kind}" == "summary"
+			# 	          def summaries
+			# 	            data_for_server[:summaries]
+			# 	          end
+			# 	        else
+			# 	          def #{kind}s
+			# 	            data_for_server[:#{kind}s]
+			# 	          end
+			# 	        end
+			# 
+			# 	        if "#{kind}" == "report"
+			# 	          def report(new_entry)
+			# 	            reports << new_entry
+			# 	          end
+			# 	        elsif "#{kind}" == "summary"
+			# 	          def summary(new_entry)
+			# 	            summaries << new_entry
+			# 	          end
+			# 	        else
+			# 	          def #{kind}(*fields)
+			# 	            #{kind}s << ( fields.first.is_a?(Hash) ?
+			# 	                          fields.first :
+			# 	                          {:subject => fields.first, :body => fields.last} )
+			# 	          end
+			# 	        end
+			# 	        alias_method :add_#{kind}, :#{kind}
+			# 	      END
+			# 	    end
 			true
 		end
 		
 		def delete_child(obj)
-			if col = get_collection(obj.collection_name)
-				col.delete obj
+			if col = collections[obj.collection_name]
+				col.delete obj.hkey
 			end
 		end
 		
 		def collection_name
-			self.class.collection_name
+			self.class.plname.underscore.to_sym
 		end
 		
 		def ref_key(ident = nil)
@@ -35,18 +74,14 @@ module Seabright
 		end
 		
 		def reference(obj)
-			raise "Not an object." unless obj.is_a?(RedisObject)
-			get_collection(obj.collection_name) << obj.hkey
+			name = obj.collection_name
+			store.sadd hkey_col, name
+			collections[name.to_s] ||= Seabright::Collection.load(name,self)
+			collections[name.to_s] << obj.hkey
 			obj.referenced_by self
 		end
-		
-		def <<(obj)
-			reference obj
-		end
-		
-		def push(obj)
-			reference obj
-		end
+		alias_method :<<, :reference
+		alias_method :push, :reference
 		
 		def remove_collection!(name)
 			store.srem hkey_col, name
@@ -89,23 +124,11 @@ module Seabright
 		end
 		
 		def has_collection?(name)
-			collection_names.include?(name.to_s)
+			store.sismember(hkey_col,name.to_s)
 		end
 		
 		def get_collection(name)
-			if has_collection?(name)
-				collections[name.to_s] ||= Collection.load(name,self)
-			else
-				store.sadd hkey_col, name
-				@collection_names << name.to_s
-				collections[name.to_s] ||= Collection.load(name,self)
-				define_access(name.to_s.pluralize) do
-					get_collection(name)
-				end
-				define_access(name.to_s.singularize) do
-					get_collection(name).latest
-				end
-			end
+			collections[name.to_s] ||= Collection.load(name,self)
 			collections[name.to_s]
 		end
 		
@@ -113,77 +136,22 @@ module Seabright
 			@collections ||= {}
 		end
 		
-		def collection_names
-			@collection_names ||= store.smembers(hkey_col)
-		end
-		
 		def mset(dat)
 			dat.select! {|k,v| !collections[k.to_s] }
 			super(dat)
 		end
 		
 		def set(k,v)
-			@data ? super(k,v) : has_collection?(k) ? get_collection(k.to_s).replace(v) : super(k,v)
+			@data ? super(k,v) : collections[k.to_s] ? get_collection(k.to_s).replace(v) : super(k,v)
 			v
 		end
 		
 		module ClassMethods
 			
-			def hkey_col(ident = nil)
+			def hkey_col(ident = id)
 				"#{hkey(ident)}:collections"
 			end
 			
-			def delete_child(obj)
-				if col = get_collection(obj.collection_name)
-					col.delete obj
-				end
-			end
-			
-			def collection_name
-				self.name.split('::').last.pluralize.underscore.to_sym
-			end
-			
-			def reference(obj)
-				name = obj.collection_name
-				store.sadd hkey_col, name
-				get_collection(name) << obj.hkey
-			end
-			
-			def <<(obj)
-				reference obj
-			end
-
-			def push(obj)
-				reference obj
-			end
-			
-			def remove_collection!(name)
-				store.srem hkey_col, name
-			end
-			
-			def get(k)
-				if has_collection?(k)
-					get_collection(k)
-				elsif has_collection?(pk = k.to_s.pluralize)
-					get_collection(pk).first
-				else
-					super(k)
-				end
-			end
-			
-			def has_collection?(name)
-				store.sismember(hkey_col,name.to_s)
-			end
-			
-			def get_collection(name)
-				collections[name.to_s] ||= Collection.load(name,self)
-				collections[name.to_s]
-			end
-			
-			def collections
-				@collections ||= {}
-			end
-			
 		end
 		
 		def self.included(base)
@@ -194,26 +162,24 @@ module Seabright
 	
 	class Collection < Array
 		
-		include Seabright::CachedScripts
-		
-		def initialize(name,owner)
+		def initialize(name,parent)
 			@name = name.to_s
-			@owner = owner
+			@parent = parent
 		end
 		
 		def remove!
-			@owner.remove_collection! @name
+			@parent.remove_collection! @name
 		end
 		
 		def latest
-			indexed(:created_at,5,true).first || first
+			indexed(:created_at,5,true).first
 		end
 		
 		def indexed(idx,num=-1,reverse=false)
 			keys = keys_by_index(idx,num,reverse)
 			out = Enumerator.new do |y|
 				keys.each do |member|
-					if a = class_const.find_by_key(member)
+					if a = RedisObject.find_by_key(member)
 						y << a
 					end
 				end
@@ -228,16 +194,18 @@ module Seabright
 		end
 		
 		def temp_key
-			"#{key}::zintersect_temp::#{RedisObject.new_id(4)}"
+			"zintersect_temp"
 		end
 		
-		RedisObject::ScriptSources::FwdScript = "redis.call('ZINTERSTORE', KEYS[1], 2, KEYS[2], KEYS[3], 'WEIGHTS', 1, 0)\nlocal keys = redis.call('ZRANGE', KEYS[1], 0, KEYS[4])\nredis.call('DEL', KEYS[1])\nreturn keys".freeze
-		RedisObject::ScriptSources::RevScript = "redis.call('ZINTERSTORE', KEYS[1], 2, KEYS[2], KEYS[3], 'WEIGHTS', 1, 0)\nlocal keys = redis.call('ZREVRANGE', KEYS[1], 0, KEYS[4])\nredis.call('DEL', KEYS[1])\nreturn keys".freeze
-		
 		def keys_by_index(idx,num=-1,reverse=false)
-			keys = run_script(reverse ? :RevScript : :FwdScript, [temp_key, index_key(idx), key, num])
+			keys = nil
+			store.multi do
+				store.zinterstore(temp_key, [index_key(idx), key], {:weights => ["1","0"]})
+				keys = store.send(reverse ? :zrevrange : :zrange, temp_key, 0, num)
+				store.del temp_key
+			end
 			Enumerator.new do |y|
-				keys.each do |member|
+				keys.value.each do |member|
 					y << member
 				end
 			end
@@ -256,15 +224,12 @@ module Seabright
 				return real_at(item_key(k))
 			elsif k.is_a? Hash
 				return match(k)
-			elsif k.is_a? Integer
+			elsif k.is_a? Number
 				return real_at(at(k))
 			end
 			return nil
 		end
-		
-		def [](k)
-			find k
-		end
+		alias_method :[], :find
 		
 		def match(pkt)
 			Enumerator.new do |y|
@@ -277,25 +242,29 @@ module Seabright
 		end
 		
 		def real_at(key)
-			class_const.find_by_key(key)
+			RedisObject.find_by_key(key)
 		end
 		
+		# def [](idx)
+		# 	class_const.find_by_key(at(idx))
+		# end
+		
 		def objects
 			each.to_a
 		end
 		
 		def first
-			class_const.find_by_key(super)
+			RedisObject.find_by_key(super)
 		end
 		
 		def last
-			class_const.find_by_key(super)
+			RedisObject.find_by_key(super)
 		end
 		
 		def each
 			out = Enumerator.new do |y|
 				each_index do |key|
-					if a = class_const.find_by_key(at(key))
+					if a = RedisObject.find_by_key(at(key))
 						y << a
 					end
 				end
@@ -311,7 +280,7 @@ module Seabright
 		
 		def cleanup!
 			each_index do |key|
-				unless a = class_const.find_by_key(at(key))
+				unless a = RedisObject.find_by_key(at(key))
 					puts "Deleting #{key} because not #{a.inspect}" if DEBUG
 					delete at(key)
 				end
@@ -330,7 +299,7 @@ module Seabright
 			return nil unless block_given?
 			Enumerator.new do |y|
 				each_index do |key|
-					if (a = class_const.find_by_key(at(key))) && block.call(a)
+					if (a = RedisObject.find_by_key(at(key))) && block.call(a)
 						y << a
 					end
 				end
@@ -352,35 +321,36 @@ module Seabright
 			store.zadd(key,store.zcount(key,"-inf", "+inf"),k)
 			super(k)
 		end
-		
-		def push(obj)
-			self << obj
-		end
+		alias_method :push, :<<
 		
 		def class_const
-			self.class.class_const_for(@name)
-		end
-		
-		def store
-			class_const.store
+			Object.const_get(@name.to_s.classify.to_sym)
 		end
 		
 		def key
-			"#{@owner ? "#{@owner.key}:" : ""}COLLECTION:#{@name}"
+			"#{@parent ? "#{@parent.key}:" : ""}COLLECTION:#{@name}"
 		end
 		
 		class << self
 			
-			def load(name,owner)
-				out = new(name,owner)
-				out.replace class_const_for(name).store.zrange(out.key,0,-1)
+			def load(name,parent)
+				out = new(name,parent)
+				out.replace store.zrange(out.key,0,-1)
 				out
 			end
 			
-			def class_const_for(name)
-				Object.const_get(name.to_s.classify.to_sym) rescue RedisObject
+			private
+			
+			def store
+				@@store ||= RedisObject.store
 			end
-
+			
+		end
+		
+		private
+		
+		def store
+			@@store ||= RedisObject.store
 		end
 		
 	end

data/lib/redis_object/defaults.rb

@@ -1,36 +1,23 @@
 module Seabright
 	module DefaultValues
 		
+		def get(k)
+			if (d = self.class.default_vals[k.to_sym]) && !d.nil?
+				return d unless is_set?(k)
+			end
+			super(k)
+		end
+		
 		module ClassMethods
 			
 			def default_vals
 				@default_vals ||= {}
 			end
 			
-			def intercept_for_defaults!
-				return if @intercepted_for_defaults
-				self.class_eval do
-					
-					alias_method :undefaulted_get, :get unless method_defined?(:undefaulted_get)
-					def get(k)
-						if !is_set?(k) && (d = self.class.default_vals[k.to_sym]) && !d.nil?
-							return d
-						end
-						undefaulted_get(k)
-					end
-					
-				end
-				@intercepted_for_defaults = true
-			end
-			
 			def register_default(k,vl)
 				default_vals[k.to_sym] = vl
-				intercept_for_defaults!
-			end
-			
-			def default_for(k,vl)
-				register_default k, vl
 			end
+			alias_method :default_for, :register_default
 			
 		end
 		

data/lib/redis_object/ext/filters.rb

@@ -1,43 +1,19 @@
 module Seabright
 	module Filters
 		
-		module ClassMethods
-			
-			def intercept_for_filters!
-				return if @intercept_for_filters
-				self.class_eval do
-					
-					def filtered_method_call(method,*args)
-						if filters = self.class.filters_for(method)
-							filters.each do |f|
-								args = send(f,*args)
-							end
-						end
-						send("unfiltered_#{method.to_s}".to_sym,*args)
-					end
-					
-					alias_method :unfiltered_get, :get unless method_defined?(:unfiltered_get)
-					def get(k)
-						filtered_method_call(:get,k)
-					end
-					
-					alias_method :unfiltered_set, :set unless method_defined?(:unfiltered_set)
-					def set(k,v)
-						filtered_method_call(:set,k,v)
-					end
-					
-					alias_method :unfiltered_setnx, :setnx unless method_defined?(:unfiltered_setnx)
-					def setnx(k,v)
-						filtered_method_call(:setnx,k,v)
-					end
-					
+		def filtered(method,*args)
+			if filters = self.class.filters_for(method)
+				filters.each do |f|
+					args = send(f,*args)
 				end
-				@intercept_for_filters = true
 			end
+			method(*args)
+		end
+		
+		module ClassMethods
 			
 			def set_filter(filter)
 				filter_method(:set,filter)
-				filter_method(:setnx,filter)
 			end
 			
 			def get_filter(filter)
@@ -45,9 +21,15 @@ module Seabright
 			end
 			
 			def filter_method(method, filter)
-				method_filters[method.to_sym] ||= []
+				unless method_filters[method.to_sym]
+					method_filters[method.to_sym] ||= []
+					filter!(method.to_sym)
+				end
 				method_filters[method.to_sym] << filter.to_sym unless method_filters[method.to_sym].include?(filter.to_sym)
-				intercept_for_filters!
+			end
+			
+			def filter!(method)
+				self.class.instance_exec("")
 			end
 			
 			def method_filters