redis_object 0.5.0

data/lib/redis_object/ext/views.rb

@@ -0,0 +1,102 @@
+module Seabright
+	module Views
+		
+		ViewFieldGetter = "local out = {}
+			local key
+			local val
+			for i=1,#ARGV do
+				key = ARGV[i]
+				val = redis.call('HGET',KEYS[1],key)
+				if val then
+					table.insert(out,key)
+					table.insert(out,val)
+				end
+			end
+			return out".gsub(/\t/,'').freeze
+		
+		def view_as_hash(name)
+			out = {}
+			if requested_set = self.class.named_views[name]
+				if requested_set.is_a?(Symbol) and self.respond_to?(requested_set)
+					out = send(requested_set)
+				else
+					methods = requested_set[:fields].select {|f| self.respond_to?(f.to_sym) }
+					if methods.count > 0
+						methods.each do |m|
+							out[m.to_s] = send(m.to_sym)
+						end
+					end
+					if requested_set[:fields] && (flds = requested_set[:fields].select {|f| !out.keys.include?(f.to_s) }.map {|f| f.to_s }) && flds.count > 0
+						res = Hash[*store.eval(ViewFieldGetter, [hkey], flds)]
+						out.merge!(res)
+					end
+					if requested_set[:procs]
+						requested_set[:procs].each do |k,proc|
+							out[k.to_s] = proc.call(self)
+						end
+					end
+					if requested_set[:hashes]
+						requested_set[:hashes].each do |k,v|
+							case v
+							when String, Symbol
+								out[k.to_s] = get(v)
+							end
+						end
+					end
+				end
+			end
+			out
+		end
+		
+		def view_as_json(name)
+			Yajl::Encoder.encode(view_as_hash(name))
+		end
+		
+		module ClassMethods
+			
+			def named_view(name,*fields)
+				named_views[name] = normalize_field_options(fields)
+			end
+			
+			def named_views
+				@named_views ||= {}
+			end
+			
+			def normalize_field_options(fields)
+				fields.flatten!
+				fields.uniq!
+
+				options = {}
+				if fields.last.is_a?(Hash) # assume an option hash
+					options.merge!(fields.slice!(fields.size - 1, 1)[0])
+				end
+
+				# assign a the method as a symbol to be exclusively invoked on view
+				# so instead of returning a hash on view, it will return only what was
+				# produced by calling the method.
+				if options.keys.size > 0 and options[:method]
+					out = options[:method].to_sym
+				else
+					hash = fields.select {|f| f.is_a?(Hash) }.inject({},:merge)
+					out = {}
+					if (h = hash.select {|k,v| !v.is_a?(Proc) }) && h.count > 0
+						out[:hashes] = h
+					end
+					if (h = hash.select {|k,v| v.is_a?(Proc) }) && h.count > 0
+						out[:procs] = h
+					end
+					if (h = fields.select {|o| o.is_a?(String) || o.is_a?(Symbol) }) && h.count > 0
+						out[:fields] = h
+					end
+				end
+				out
+			end
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

data/lib/redis_object/external_index.rb

@@ -0,0 +1,25 @@
+module Seabright
+	class ExternalIndex
+		
+		class << self
+			
+			def buildthisout
+			end
+			
+			private
+			
+			def redis
+				@@redis ||= Seabright::RedisPool.connection
+			end
+			
+		end
+		
+		private
+		
+		def redis
+			@@redis ||= self.class.redis
+		end
+		
+	end
+	
+end

data/lib/redis_object/indices.rb

@@ -0,0 +1,97 @@
+module Seabright
+	module Indices
+		
+		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
+			end
+			
+			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|
+						if a = self.find_by_key(member)
+							yielder << a
+						end
+					end
+				end
+				if block_given?
+					out.each do |itm|
+						yield itm
+					end
+				else
+					out
+				end
+			end
+			
+			def index_key(idx)
+				"#{self.plname}::#{idx}"
+			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)
+				sort_indices.include?(k.to_sym)
+			end
+			
+			def latest
+				indexed(:created_at,999,true).first
+			end
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

data/lib/redis_object/inheritance_tracking.rb

@@ -0,0 +1,23 @@
+module Seabright
+	module InheritanceTracking
+		
+		module ClassMethods
+			def inherited(child_class)
+				child_classes_set.add(child_class)
+			end
+
+			def child_classes_set
+				@child_classes_set ||= Set.new
+			end
+
+			def child_classes
+				child_classes_set.to_a
+			end
+		end
+
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

data/lib/redis_object/keys.rb

@@ -0,0 +1,37 @@
+module Seabright
+	module Keys
+		
+		def key(ident = id)
+			"#{self.class.cname}:#{ident.gsub(/^.*:/,'')}"
+		end
+		
+		def reserve_key(ident = id)
+			"#{key(ident)}_reserve"
+		end
+		
+		def hkey(ident = nil)
+			"#{key}_h"
+		end
+		
+		module ClassMethods
+			
+			def key(ident=nil)
+				"#{cname}#{ident ? ":#{ident.gsub(/^.*:/,'')}" : ""}"
+			end
+			
+			def reserve_key(ident=nil)
+				"#{key(ident)}_reserve"
+			end
+			
+			def hkey(ident = nil)
+				"#{key(ident)}_h"
+			end
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

data/lib/redis_object/storage.rb

@@ -0,0 +1,93 @@
+module Seabright
+	module Storage
+		
+		require 'redis_object/storage/adapter'
+		autoload :Redis, 'redis_object/storage/redis'
+		autoload :MySQL, 'redis_object/storage/mysql'
+		
+		def store
+			self.class.store
+		end
+		
+		module ClassMethods
+			
+			def set_storage(adp=adapter)
+				@adapter = adp
+			end
+			
+			def store(id=store_name)
+				adapters[id] ||= const_get(adapter).new(config(id))
+			end
+			
+			def configure_store(conf,id=store_name,*ids)
+				configs[id] = conf
+				ids.each do |i|
+					configs[i] = conf
+				end
+				store(id)
+			end
+			
+			def use_store(id)
+				raise "Cannot use non-existent store: #{id}" unless config(id)
+				@store_name = id.to_sym
+			end
+			
+			def reconnect!
+				adapters.each do |k,v|
+					v.reconnect!
+				end
+			end
+			
+			def adapters
+				@@adapters ||= {}
+			end
+			
+			def adapter
+				@adapter ||= config[:adapter].to_sym || :Redis
+			end
+			
+			def store_name
+				@store_name ||= :global
+			end
+			
+			def configs
+				@@conf ||= {}
+			end
+			
+			def config(id=store_name)
+				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)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

data/lib/redis_object/storage/adapter.rb

@@ -0,0 +1,46 @@
+module Seabright
+	module Storage
+		class Adapter
+			
+			def initialize(config={})
+				@config = config
+			end
+			
+			def configure(conf)
+				@config = conf
+				reset
+			end
+			
+			def config
+				@config ||= {}
+			end
+			
+			def config_opts(*opts)
+				opts.inject({}) do |a,k|
+					a[k] = config[k]
+					a
+				end
+			end
+			
+			def reset
+				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 ||= []
+			end
+			
+			def new_connection
+				true
+			end
+			
+		end
+	end
+end

data/lib/redis_object/storage/aws.rb

@@ -0,0 +1,71 @@
+
+module Seabright
+	module Storage
+		class AWS
+			
+			def initialize(config={})
+				puts "Got config: '#{config.inspect}'"
+				@config = config
+			end
+			
+			def configure(conf)
+				@config = conf
+				reset
+			end
+			
+			def set
+				
+			end
+			
+			def sadd
+				
+			end
+			
+			def del
+				
+			end
+			
+			def srem
+				
+			end
+			
+			def smembers
+				
+			end
+			
+			def exists
+				
+			end
+			
+			def hget
+				
+			end
+			
+			def hset
+				
+			end
+			
+			private
+			
+			def reset
+				@connection = nil
+			end
+			
+			def connection
+				@connection ||= new_connection
+			end
+			
+			def new_connection
+				require 'fog'
+				require 'aws-sdk'
+				
+				opts = [:path, :db, :password].inject({}) {|a,k| 
+					a[k] = @config[k]
+					a
+				}
+				::Redis.new(opts)
+			end
+			
+		end
+	end
+end