redis_object 0.5.0

data/lib/redis_object/storage/mysql.rb

@@ -0,0 +1,47 @@
+module Seabright
+	module Storage
+		class MySQL
+			
+			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 connection(num=0)
+				require 'mysql'
+				@connections ||= []
+				@connections[num] ||= MySQL.new
+			end
+			
+		end
+	end
+end

data/lib/redis_object/storage/redis.rb

@@ -0,0 +1,119 @@
+module Seabright
+	module Storage
+		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)
+				rescue ::Redis::InheritedError => err
+					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
+			end
+			
+		end
+	end
+end

data/lib/redis_object/timestamps.rb

@@ -0,0 +1,74 @@
+module Seabright
+	module Timestamps
+		
+		def update_timestamps
+			# return unless self.class.time_matters?
+			set(:created_at, Time.now) if !is_set?(:created_at)
+			set(:updated_at, Time.now)
+		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
+			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
+			
+			def recently_updated(num=5)
+				self.indexed(:updated_at,num,true)
+			end
+			
+		end
+		
+		def self.included(base)
+			# @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
+end

data/lib/redis_object/tpl.rb

@@ -0,0 +1,17 @@
+module Seabright
+	module Template
+		
+		
+		
+		module ClassMethods
+			
+			
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end

data/lib/redis_object/types.rb

@@ -0,0 +1,276 @@
+module Seabright
+	module Types
+		
+		def enforce_format(k,v)
+			if v && fmt = self.class.field_formats[k.to_sym] 
+				send(fmt,v)
+			else 
+				v
+			end
+		end
+		
+		def score_format(k,v)
+			if v && fmt = self.class.score_formats[k.to_sym] 
+				send(fmt,v)
+			else 
+				0
+			end
+		end
+		
+		def save_format(k,v)
+			v && (fmt = self.class.save_formats[k.to_s.gsub(/\=$/,'').to_sym]) ? send(fmt,v) : v
+		end
+		
+		def format_date(val)
+			begin
+				val.is_a?(DateTime) || val.is_a?(Date) || val.is_a?(Time) ? val : ( val.is_a?(String) ? DateTime.parse(val) : nil )
+			rescue StandardError => e
+				puts "Could not parse value as date using Date.parse. Returning nil instead. Value: #{val.inspect}\nError: #{e.inspect}" if DEBUG
+				nil
+			end
+		end
+		
+		def score_date(val)
+			val.to_time.to_i
+		end
+		
+		def format_array(val)
+			Yajl::Parser.new(:symbolize_keys => true).parse(val)
+		end
+		
+		def save_array(val)
+			Yajl::Encoder.encode(val)
+		end
+		
+		def format_number(val)
+			val.to_i
+		end
+		
+		def score_number(val)
+			Float(val)
+		end
+		
+		def format_float(val)
+			Float(val)
+		end
+		alias_method :score_float, :format_float
+		
+		def format_json(val)
+			Yajl::Parser.new(:symbolize_keys => true).parse(val)
+		end
+		
+		def save_json(val)
+			Yajl::Encoder.encode(val)
+		end
+		
+		def format_boolean(val)
+			val=="true"
+		end
+		
+		def save_boolean(val)
+			val === true ? "true" : "false"
+		end
+		
+		def score_boolean(val)
+			val ? 1 : 0
+		end
+		
+		module ClassMethods
+			
+			def date(k)
+				set_field_format(k, :format_date)
+				set_score_format(k, :score_date)
+			end
+			
+			def number(k)
+				set_field_format(k, :format_number)
+				set_score_format(k, :score_number)
+			end
+			alias_method :int, :number
+			
+			def float(k)
+				set_field_format(k, :format_float)
+				set_score_format(k, :score_float)
+			end
+			
+			def bool(k)
+				set_field_format(k, :format_boolean)
+				set_score_format(k, :score_boolean)
+				set_save_format(k, :save_boolean)
+			end
+			alias_method :boolean, :bool
+			
+			def array(k)
+				set_field_format(k, :format_array)
+				set_save_format(k, :save_array)
+			end
+			
+			def json(k)
+				set_field_format(k, :format_json)
+				set_save_format(k, :save_json)
+			end
+			
+			def field_formats
+				@field_formats_hash ||= (defined?(superclass.field_formats) ? superclass.field_formats.clone : {})
+			end
+			
+			def score_formats
+				@score_formats_hash ||= (defined?(superclass.score_formats) ? superclass.score_formats.clone : {})
+			end
+			
+			def save_formats
+				@save_formats_hash ||= (defined?(superclass.save_formats) ? superclass.save_formats.clone : {})
+			end
+			
+			def set_field_format(k, v)
+				field_formats_set_locally.add(k)
+				field_formats[k] = v
+				update_child_class_field_formats(k, v)
+				intercept_for_typing!
+			end
+			
+			def field_formats_set_locally
+				@field_formats_set_locally_set ||= Set.new
+			end
+			
+			def inherit_field_format(k, v)
+				unless fields_formats_set_locally.include? k
+					field_formats[k] = v
+					update_child_class_field_formats(k, v)
+				end
+				intercept_for_typing!
+			end
+			
+			def update_child_class_field_formats(k, v)
+				child_classes.each do |child_class|
+					child_class.inherit_field_format(k, v)
+				end
+			end
+			
+			def set_score_format(k, v)
+				score_formats_set_locally.add(k)
+				score_formats[k] = v
+				update_child_class_score_formats(k, v)
+				intercept_for_typing!
+			end
+			
+			def score_formats_set_locally
+				@score_formats_set_locally_set ||= Set.new
+			end
+			
+			def inherit_score_format(k, v)
+				unless scores_formats_set_locally.include? k
+					score_formats[k] = v
+					update_child_class_score_formats(k, v)
+				end
+				intercept_for_typing!
+			end
+			
+			def update_child_class_score_formats(k, v)
+				child_classes.each do |child_class|
+					child_class.inherit_score_format(k, v)
+				end
+			end
+			
+			def set_save_format(k, v)
+				save_formats_set_locally.add(k)
+				save_formats[k] = v
+				update_child_class_save_formats(k, v)
+				intercept_for_typing!
+			end
+			
+			def save_formats_set_locally
+				@save_formats_set_locally_set ||= Set.new
+			end
+			
+			def inherit_save_format(k, v)
+				unless save_formats_set_locally.include? k
+					save_formats[k] = v
+					update_child_class_save_formats(k, v)
+				end
+				intercept_for_typing!
+			end
+			
+			def update_child_class_save_formats(k, v)
+				child_classes.each do |child_class|
+					child_class.inherit_save_format(k, v)
+				end
+			end
+			
+			def register_format(k,fmt)
+				send(fmt, k)
+			end
+			
+			def describe
+				all_keys.inject({}) do |acc,(k,v)|
+					if field_formats[k.to_sym]
+						acc[k.to_sym] ||= [field_formats[k.to_sym].to_s.gsub(/^format_/,'').to_sym, 0]
+					else
+						acc[k.to_sym] ||= [:string, 0]
+					end
+					acc[k.to_sym][1] += 1
+					acc
+				end
+			end
+			
+			def dump_schema(file)
+				child_classes_set.sort {|a,b| a.name <=> b.name}.each do |child|
+					file.puts "# #{child.name}"
+					# sort fields by number of instances found
+					child.describe.sort {|a,b| b[1][1] <=> a[1][1]}.each do |field,(type, count)|
+						file.puts "#{field}: #{type} (#{count})"
+					end
+					file.puts
+				end
+			end
+			
+			def intercept_for_typing!
+				return if @intercepted_for_typing
+				self.class_eval do
+					
+					alias_method :untyped_get, :get unless method_defined?(:untyped_get)
+					def get(k)
+						enforce_format(k,untyped_get(k))
+					end
+					
+					alias_method :untyped_mset, :mset unless method_defined?(:untyped_mset)
+					def mset(dat)
+						dat.merge!(dat) {|k,v1,v2| save_format(k,v1) }
+						untyped_mset(dat)
+					end
+					
+					alias_method :untyped_set, :set unless method_defined?(:untyped_set)
+					def set(k,v)
+						untyped_set(k,save_format(k,v))
+					end
+					
+					alias_method :untyped_setnx, :setnx unless method_defined?(:untyped_setnx)
+					def setnx(k,v)
+						untyped_setnx(k,save_format(k,v))
+					end
+					
+				end
+				@intercepted_for_typing = true
+			end
+			
+			private
+			
+			def all_keys(limit=100)
+				steps = 0
+				all.inject([]) do |acc,obj|
+					store.hkeys(obj.hkey).each do |k|
+						acc << k.to_sym
+					end
+					steps += 1
+					return acc if steps >= limit
+					acc
+				end
+			end
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end