redis_object 1.0 → 1.1

data/lib/redis_object/timestamps.rb

@@ -2,34 +2,54 @@ module Seabright
 	module Timestamps
 		
 		def update_timestamps
-			return if @@time_irrelevant
+			# return unless self.class.time_matters?
 			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 time_matters_not!
-				@@time_irrelevant = true
-				@@sort_indices.delete(:created_at)
-				@@sort_indices.delete(:updated_at)
+			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
@@ -41,12 +61,13 @@ 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

data/lib/redis_object/types.rb

@@ -22,7 +22,12 @@ module Seabright
 		end
 		
 		def format_date(val)
-			val.instance_of?(DateTime) ? val : DateTime.parse(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)
@@ -30,7 +35,11 @@ module Seabright
 		end
 		
 		def format_array(val)
-			eval val
+			Yajl::Parser.new(:symbolize_keys => true).parse(val)
+		end
+		
+		def save_array(val)
+			Yajl::Encoder.encode(val)
 		end
 		
 		def format_number(val)
@@ -58,72 +67,205 @@ module Seabright
 			val=="true"
 		end
 		
-		def score_boolean(val)
-			val ? 1 : 0
-		end
-		
-		def get(k)
-			enforce_format(k,super(k))
+		def save_boolean(val)
+			val === true ? "true" : "false"
 		end
 		
-		def mset(dat)
-			dat.merge!(dat) {|k,v1,v2| save_format(k,v1) }
-			super(dat)
-		end
-		
-		def set(k,v)
-			super(k,save_format(k,v))
+		def score_boolean(val)
+			val ? 1 : 0
 		end
 		
 		module ClassMethods
 			
 			def date(k)
-				field_formats[k] = :format_date
-				score_formats[k] = :score_date
+				set_field_format(k, :format_date)
+				set_score_format(k, :score_date)
 			end
 			
 			def number(k)
-				field_formats[k] = :format_number
-				score_formats[k] = :score_number
+				set_field_format(k, :format_number)
+				set_score_format(k, :score_number)
 			end
 			alias_method :int, :number
 			
 			def float(k)
-				field_formats[k] = :format_float
-				score_formats[k] = :score_float
+				set_field_format(k, :format_float)
+				set_score_format(k, :score_float)
 			end
 			
 			def bool(k)
-				field_formats[k] = :format_boolean
-				score_formats[k] = :score_boolean
+				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)
-				field_formats[k] = :format_array
+				set_field_format(k, :format_array)
+				set_save_format(k, :save_array)
 			end
 			
 			def json(k)
-				field_formats[k] = :format_json
-				save_formats[k] = :save_json
+				set_field_format(k, :format_json)
+				set_save_format(k, :save_json)
 			end
 			
 			def field_formats
-				@@field_formats ||= {}
+				@field_formats_hash ||= (defined?(superclass.field_formats) ? superclass.field_formats.clone : {})
 			end
 			
 			def score_formats
-				@@score_formats ||= {}
+				@score_formats_hash ||= (defined?(superclass.score_formats) ? superclass.score_formats.clone : {})
 			end
 			
 			def save_formats
-				@@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)
@@ -131,4 +273,4 @@ module Seabright
 		end
 		
 	end
-end
+end

data/lib/redis_object/version.rb

@@ -1,5 +1,5 @@
 module Seabright
 	class RedisObject
-		VERSION = "1.0"
+		VERSION = "1.1"
 	end
 end

data/redis_object.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   s.required_ruby_version = '>= 1.9.2'
+  s.add_dependency "utf8_utils"
   s.add_dependency "redis"
   s.add_dependency "yajl-ruby"
   s.add_dependency "activesupport"

data/spec/adapter_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module ObjectTests
+	class User < RedisObject
+		use_store :global
+	end
+	class Thingy < RedisObject
+		
+	end
+	class Doodad < RedisObject
+		
+	end
+end
+
+describe RedisObject do
+	
+	it "can reconnect to redis" do
+		RedisObject.reconnect!
+		RedisObject.store.reconnect!
+	end
+	
+	it "can dump to a file" do
+		obj = ObjectTests::User.create("test")
+		RedisObject.dump_stores_to_files("/tmp")
+		RedisObject.store.flushdb
+	end
+	
+	it "can restore from a file" do
+		RedisObject.restore_stores_from_files("/tmp")
+		ObjectTests::User.find("test").should be_a(ObjectTests::User)
+	end
+	
+	it "can get all stores" do
+		RedisObject.stores.count.should eq(1)
+	end
+	
+	it "can reset stores" do
+		RedisObject.stores.each do |(name,store)|
+			store.reset
+		end
+	end
+	
+end

data/spec/base_spec.rb

@@ -1,10 +1,8 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-DEBUG = false
-
 module ObjectTests
 	class User < RedisObject
-		
+		use_store :global
 	end
 	class Thingy < RedisObject
 		
@@ -15,41 +13,78 @@ module ObjectTests
 end
 
 describe RedisObject do
+	
 	it "can be created" do
 		obj = ObjectTests::User.new
 	end
+	
 	it "can be created with an id" do
 		obj = ObjectTests::User.new("test")
 		obj.save
 	end
+	
+	it "can create an id" do
+		obj = ObjectTests::User.new("test")
+		obj.new_id
+	end
+	
+	it "can reserve an id" do
+		obj = ObjectTests::User.new("test")
+		obj.reserve("test")
+	end
+	
 	it "should be found by id" do
 		obj = ObjectTests::User.find("test")
 		obj.should_not be_nil
 	end
+	
+	it "can recollect objects" do
+		ObjectTests::User.recollect!
+	end
+	
+	it "get get the first object (random)" do
+		obj = ObjectTests::User.first
+		obj.should be_a(ObjectTests::User)
+	end
+	
 	it "should save stuff" do
 		obj = ObjectTests::User.find("test")
 		obj.stuff = "yay!"
-		obj.stuff.should == "yay!"
+		obj[:stuff].should eq("yay!")
+		obj[:stuff] = "yayyay!"
+		obj.stuff.should eq("yayyay!")
+		obj.stuff = "yay!"
+		obj.stuff.should eq("yay!")
 	end
+	
 	it "should retrieve stuff" do
 		obj = ObjectTests::User.find("test")
-		obj.stuff.should == "yay!"
+		obj.stuff.should eq("yay!")
 	end
+	
 	it "can collect other objects" do
 		obj = ObjectTests::User.find("test")
 		obj2 = ObjectTests::Thingy.new("yay")
 		obj << obj2
 		obj.should have_collection(:thingies)
 	end
+	
 	it "can reference other objects" do
 		obj = ObjectTests::User.find("test")
 		obj3 = ObjectTests::Doodad.new("woo")
 		obj.reference obj3
 		obj.should have_collection(:doodads)
 	end
+	
+	it "can convert raw to json" do
+		obj = ObjectTests::User.find("test")
+		obj.to_json.length.should > 0
+	end
+	
 	it "should be deletable" do
 		obj = ObjectTests::User.find("test")
 		obj.delete!
 		ObjectTests::User.find("test").should be_nil
 	end
-end
+	
+end