redis_object 0.5.0 → 1.0

data/.coveralls.yml

@@ -1 +0,0 @@
-repo_token: 8vq1j1WGB56M8h1zI6TeuK7x3HVJ1K8l4

data/.travis.yml

@@ -1,5 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-env:
-  - "TEST_DB=14"

data/lib/redis_object/ext/script_cache.rb

@@ -1,92 +0,0 @@
-$ScriptSHAMap = {}
-
-module Seabright
-	
-	class RedisObject
-		module ScriptSources; end
-	end
-	
-	module CachedScripts
-		
-		def run_script(name,keys=[],args=[],source=nil)
-			self.class.run_script(name,keys,args,source,store)
-		end
-		
-		module ClassMethods
-			
-			NoScriptError = "NOSCRIPT No matching script. Please use EVAL.".freeze
-			
-			def run_script(name,keys=[],args=[],source=nil,stor=nil)
-				@tmp_store = stor if stor
-				@rescue_recurse ||= 0
-				begin
-					out = (@tmp_store || store).evalsha(get_script_sha(name,source),keys,args)
-				rescue Redis::CommandError => e
-					if e.message == NoScriptError && @rescue_recurse < 3
-						puts "Rescuing NOSCRIPT error for #{name} - running again..." if DEBUG
-						untrack_script name
-						@rescue_recurse += 1
-						out = (@tmp_store || store).evalsha(get_script_sha(name,source),keys,args)
-					else
-						@rescue_recurse = 0
-						raise e
-					end
-				end
-				@rescue_recurse = 0
-				remove_instance_variable(:@tmp_store) if @tmp_store
-				out
-			end
-			
-			def get_script_sha(name,source=nil)
-				$ScriptSHAMap[name] ||= (script_sha_from_key(name) || store_script(name,source))
-			end
-			
-			def script_sha_from_key(name)
-				(@tmp_store || store).get(script_sha_key(name))
-			end
-			
-			class SourceNotFoundError < RuntimeError
-				def initialize
-					super("Could not locate script source")
-				end
-			end
-			
-			def store_script(name,source=nil)
-				source ||= script_source_from_const(name)
-				raise SourceNotFoundError unless source
-				sha = (@tmp_store || store).script(:load,source)
-				(@tmp_store || store).set(script_sha_key(name),sha)
-				sha
-			end
-			
-			def untrack_script(name)
-				ScriptSHAMap.delete name
-				(@tmp_store || store).del(script_sha_key(name))
-			end
-			
-			def script_source_from_const(name)
-				(self.const_defined?(name.to_sym) && self.const_get(name.to_sym)) || (RedisObject::ScriptSources.const_defined?(name.to_sym) && RedisObject::ScriptSources.const_get(name.to_sym)) || nil
-			end
-			
-			SCRIPT_KEY_PREFIX = "ScriptCache::SHA::".freeze
-			
-			def expire_all_script_shas(store_name=nil)
-				store_obj = store_name.is_a?(String) || store_name.is_a?(Symbol) ? store(store_name.to_sym) : store_name
-				store_obj.keys(script_sha_key("*")).each do |k|
-					store_obj.del k
-				end
-			end
-			
-			def script_sha_key(name)
-				"#{SCRIPT_KEY_PREFIX}#{name.to_s}"
-			end
-			
-		end
-		
-		def self.included(base)
-			base.extend(ClassMethods)
-		end
-		
-	end
-	
-end

data/lib/redis_object/ext/shardable.rb

@@ -1,18 +0,0 @@
-module Seabright
-	module Shardable
-		
-		# Intention is to override any methods needed so that the underlying data can be safely sharded
-		
-		module ClassMethods
-			
-			# same here
-			
-		end
-		
-		def self.included(base)
-			base.extend(ClassMethods)
-		end
-		
-	end
-	RedisObject.send(:include,Shardable)
-end

data/lib/redis_object/ext/view_caching.rb

@@ -1,258 +0,0 @@
-# View Caching
-# 
-# Cache a named view:
-#   cache_named_view :admin_view
-# 
-# Invalidate all cached views when the I receive notification that something I reference or have been referenced by has changed:
-#   invalidate_caches_from_upstream_updates!
-# 
-# Notify some objects that reference me when I am updated: (objects of these classes)
-#   invalidate_upstream Property, Application, PaymentRequest, PaymentResponse
-# 
-# Notify some objects in my collections when I am updated: (objects in these collections)
-#   invalidate_downstream :properties, :applications, :payment_requests, :payment_responses
-# 
-# You can also set up hooks for when this object is updated by certain types of objects by defining the following:
-#   def invalidated_by(obj,chain)
-#     invalidate_cached_view :blah
-#   end
-#   
-#   def invalidated_by_user(obj,chain)
-#     invalidate_cached_view :users
-#   end
-#   
-
-module Seabright
-	module ViewCaching
-		
-		CachedViewInvalidator = "
-			for i=1,#ARGV do
-				redis.call('HDEL', KEYS[1], ARGV[i])
-			end".gsub(/\t/,'').freeze
-				
-		module ClassMethods
-			
-			def cache_view(name,opts=true)
-				cached_views[name.to_sym] = opts
-				intercept_views_for_caching!
-				set_up_invalidation!
-			end
-			alias_method :cache_named_view, :cache_view
-			
-			def intercept_views_for_caching!
-				return if @cached_views_intercepted
-				self.class_eval do
-					
-					alias_method :uncached_view_as_hash, :view_as_hash unless method_defined?(:uncached_view_as_hash)
-					def view_as_hash(name)
-						return uncached_view_as_hash(name) unless self.class.view_should_be_cached?(name)
-						if v = view_from_cache(name)
-							puts "  Got view from cache: #{name}" if DEBUG
-							Yajl::Parser.parse(v)
-						else
-							puts "  View cache miss: #{name}" if DEBUG
-							cache_view_content(name)[0]
-						end
-					end
-					
-					alias_method :uncached_view_as_json, :view_as_json unless method_defined?(:uncached_view_as_json)
-					def view_as_json(name)
-						return uncached_view_as_json(name) unless self.class.view_should_be_cached?(name)
-						if v = view_from_cache(name)
-							puts "  Got view from cache: #{name}" if DEBUG
-							v
-						else
-							puts "  View cache miss: #{name}" if DEBUG
-							cache_view_content(name)[1]
-						end
-					end
-					
-					def cache_view_content(name,content=nil)
-						content ||= uncached_view_as_hash(name)
-						json = Yajl::Encoder.encode(content)
-						store.hset(cached_view_key,name,json)
-						[content,json]
-					end
-					
-					def view_from_cache(name)
-						if v = store.hget(cached_view_key,name)
-							v
-						else
-							nil
-						end
-					end
-					
-					def view_is_cached?(name)
-						store.hexists(cached_view_key, name)
-					end
-					
-					def cached_view_key
-						"#{hkey}::ViewCache"
-					end
-					
-					def regenerate_cached_views(*names)
-						names.each do |name|
-							cache_view_content name
-						end
-					end
-					
-					def regenerate_cached_views!
-						regenerate_cached_views(*self.class.cached_views.map {|name,opts| name })
-					end
-					
-				end
-				@cached_views_intercepted = true
-			end
-			
-			def set_up_invalidation!
-				return if @invalidation_set_up
-				self.class_eval do
-					
-					def invalidate_cached_views(*names)
-						puts "Invalidating cached views: #{names.join(", ")}" if Debug.verbose?
-						run_script(:CachedViewInvalidator, [cached_view_key], names, CachedViewInvalidator)
-						self.class.cache_invalidation_hooks do |hook|
-							hook.call(names)
-						end
-					end
-					alias_method :invalidate_cached_view, :invalidate_cached_views
-					
-					def invalidate_cached_views!
-						invalidate_cached_views(*self.class.cached_views.map {|name,opts| name })
-					end
-					
-					def invalidate_downstream!
-						return unless self.class.downstream_invalidations && (self.class.downstream_invalidations.size > 0)
-						puts "Invalidating downstream: #{self.class.downstream_invalidations.inspect}" if Debug.verbose?
-						self.class.downstream_invalidations.each do |col|
-							if has_collection?(col) && (colctn = get_collection(col))
-								colctn.each do |obj|
-									obj.invalidated_by_other(self,invalidation_chain + [self.hkey])
-								end
-							end
-						end
-					end
-					
-					def invalidate_upstream!
-						return unless self.class.upstream_invalidations && (self.class.upstream_invalidations.size > 0)
-						puts "Invalidating upstream: #{self.class.upstream_invalidations.inspect}" if Debug.verbose?
-						backreferences.each do |obj|
-							next unless self.class.upstream_invalidations.include?(obj.class.name.split("::").last.to_sym) #|| self.class.invalidate_everything_upstream?
-							obj.invalidated_by_other(self,invalidation_chain + [self.hkey]) if obj.respond_to?(:invalidated_by_other)
-						end
-					end
-					
-					def invalidated_by_update!(*args)
-						Thread.new do
-							invalidate_cached_views!
-							invalidate_up_and_down!
-						end
-					end
-					
-					def invalidated_by_reference!(*args)
-						invalidated_by_update!
-					end
-					
-					def invalidation_chain
-						@invalidation_chain ||= []
-					end
-					
-					def invalidate_up_and_down!
-						unless invalidation_chain.include?(self)
-							invalidate_downstream!
-							invalidate_upstream!
-						end
-					end
-					
-					def invalidated_by_other(obj,chain)
-						unless chain.include?(self.hkey)
-							puts "#{self.class.name}:#{self.id}'s view caches were invalidated by upstream object: #{obj.class.name}:#{obj.id} (chain:#{chain.inspect})" if Debug.verbose?
-							@invalidation_chain = chain
-							[:invalidated_by,"invalidated_by_#{obj.class.name.underscore}".to_sym].each do |meth_sym|
-								send(meth_sym,obj,chain) if respond_to?(meth_sym)
-							end
-							invalidate_up_and_down!
-						end
-					end
-					
-					trigger_on_update :invalidated_by_update!
-					trigger_on_reference :invalidated_by_reference!
-					
-				end
-				@invalidation_set_up = true
-			end
-			
-			def invalidate_caches_from_upstream_updates!
-				self.class_eval do
-					
-					def invalidated_by(obj,chain)
-						invalidate_cached_views!
-					end
-					
-				end
-			end
-			
-			def on_cache_invalidation(&block)
-				cache_invalidation_hooks << block
-			end
-			
-			def cache_invalidation_hooks
-				@cache_invalidation_hooks ||= []
-			end
-			
-			def invalidate_upstream(*args)
-				@upstream_invalidations = (@upstream_invalidations || []) + args
-				set_up_invalidation!
-			end
-			
-			def upstream_invalidations
-				@upstream_invalidations ||= []
-			end
-			
-			# def invalidate_everything_upstream!
-			# 	@invalidate_everything_upstream = true
-			# end
-			# 
-			# def invalidate_everything_upstream?
-			# 	@invalidate_everything_upstream
-			# end
-			
-			def invalidate_downstream(*args)
-				@downstream_invalidations = (@downstream_invalidations || []) + args
-				set_up_invalidation!
-			end
-			
-			def downstream_invalidations
-				@downstream_invalidations ||= []
-			end
-			
-			# def invalidate_everything_downstream!
-			# 	@invalidate_everything_downstream = true
-			# end
-			# 
-			# def invalidate_everything_downstream?
-			# 	@invalidate_everything_downstream
-			# end
-			
-			def view_should_be_cached?(name)
-				!!cached_views[name.to_sym]
-			end
-			
-			def cached_views
-				@cached_view ||= {}
-			end
-			
-			def cache_named_views!
-				named_views.each do |name,view|
-					cache_view name
-				end
-			end
-			
-		end
-		
-		def self.included(base)
-			base.extend(ClassMethods)
-		end
-		
-	end
-end

data/lib/redis_object/ext/views.rb

@@ -1,102 +0,0 @@
-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