redis_object 0.5.0

data/lib/redis_object/validation.rb

@@ -0,0 +1,89 @@
+module Seabright
+	
+	module Validation
+		
+		def valid?
+			ret = true
+			errors = []
+			self.class.required_fields.each do |k|
+				unless is_valid?(k)
+					errors.push "#{k} is not valid and is needed to process."
+					ret = false
+				end
+			end
+			self.class.required_collections.each do |k|
+				unless has_collection?(k)
+					errors.push "Need a #{k} collection to proceed."
+					ret = false
+				end
+			end
+			ret
+		end
+		
+		def is_set?(k)
+			store.hexists(hkey,k)
+		end
+		
+		def is_valid?(k)
+			return false unless is_set?(k)
+			return true unless validations[k]
+			if val = get(k)
+				case validations[k].class
+				when Regexp
+					return false unless validations[k].match(val)
+				when Array
+					return false unless validations[k].include?(val)
+				else
+					if validations[k].class == Class
+						return false unless val.class == validations[k]
+					end
+				end
+			end
+			true
+		end
+		
+		def validations
+			@validations ||= self.class.validations
+		end
+		
+		module ClassMethods
+			
+			def require_field(*args)
+				args.each do |k|
+					required_fields.push k.to_sym
+				end
+			end
+			alias_method :require_fields, :require_field
+			
+			def require_collection(*args)
+				args.each do |k|
+					required_collections.push k.to_sym
+				end
+			end
+			alias_method :require_collections, :require_collection
+			
+			def required_collections
+				@required_cols ||= []
+			end
+			
+			def required_fields
+				@required ||= []
+			end
+			
+			def validate(k,rl)
+				validations[k] = rl
+			end
+			
+			def validations
+				@validations ||= {}
+			end
+			
+		end
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+	
+end

data/lib/redis_object/version.rb

@@ -0,0 +1,5 @@
+module Seabright
+	class RedisObject
+		VERSION = "0.5.0"
+	end
+end

data/redis_object.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis_object/version"
+
+Gem::Specification.new do |s|
+  s.name        = "redis_object"
+  s.version     = Seabright::RedisObject::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["John Bragg"]
+  s.email       = ["john@seabrightstudios.com"]
+  s.homepage    = ""
+  s.summary     = %q{Maps arbitrary objects to a Redis store with indices and smart retrieval and storage mechanisms.}
+  s.description = %q{}
+
+  s.rubyforge_project = "redis_object"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  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"
+end

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

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

data/spec/benchmark_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module BenchmarkSpec
+	
+	TestValues = {
+		date: Date.today,
+		number: 27,
+		int: 356192,
+		float: 72.362517,
+		bool: true,
+		# boolean: false,
+		# array: [:test1,:test2],
+		json: {test1: true, test2: "false"}
+	}
+	
+	TestData = TestValues.inject({}){|acc,(k,v)| acc["a_#{k}".to_sym] = v; acc }
+	
+	class BenchmarkedObject < RedisObject
+		
+		TestValues.keys.each do |type|
+			send(type.to_sym,"a_#{type}".to_sym)
+		end
+		
+		def aggregate
+			sleep 0.1
+			42.7
+		end
+		benchmark :aggregate
+		
+	end
+	
+	describe Seabright::Benchmark do
+		before do
+			RedisObject.store.flushdb
+		end
+		
+		it "benchmarks a call" do
+			
+			obj = BenchmarkedObject.create(TestData)
+			
+			obj.aggregate.should eq(42.7)
+			
+		end
+						
+	end
+end

data/spec/collections_spec.rb

@@ -0,0 +1,144 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module CollectionSpec
+	
+	class GrandDad < RedisObject; end
+	class Daddy < RedisObject; end
+	class Son < RedisObject; end
+	class GrandSon < RedisObject; end
+	
+	describe Seabright::Collections do
+		before do
+			
+			RedisObject.store.flushdb
+			@granddad = GrandDad.create("gramps")
+			@dad = Daddy.create("dad")
+			@son = Son.create("sun")
+			@sonny = Son.create("sonny")
+			@grandson = GrandSon.create("baby")
+			GrandDad << @dad
+			@granddad << @dad
+			@granddad << @son
+			@dad << @son
+			@dad.push @sonny
+			@son.reference @grandson
+			
+		end
+		
+		it "can reference other objects" do
+			
+			@granddad.daddies.count.should eq(1)
+			@granddad.sons.count.should eq(1)
+			@dad.sons.count.should eq(2)
+			
+		end
+		
+		it "should have appropriate collections" do
+			
+			@granddad.has_collection?(:daddies).should eq(true)
+			@granddad.has_collection?(:sons).should eq(true)
+			@granddad.has_collection?(:grand_sons).should eq(false)
+			
+		end
+		
+		it "should cache collection accessors" do
+			
+			@granddad.daddies.should be_a(Seabright::Collection)
+			@granddad.daddy.should be_a(Daddy)
+			
+		end
+		
+		it "should be able to iterate over collected items" do
+			
+			@dad.sons.count.should eq(2)
+			@dad.sons.each do |s|
+				s.should be_a(Son)
+			end
+			
+		end
+		
+		it "can find items in a collection" do
+			
+			@dad = Daddy.find("dad")
+			@dad.sons.find(son_id: "sonny").first.should be_a(Son)
+			
+		end
+		
+		it "can get one collection item" do
+			
+			@dad = Daddy.find("dad")
+			@dad.son.should be_a(Son)
+			
+		end
+		
+		it "can get one collection item" do
+			
+			@dad = Daddy.find("dad")
+			@dad.get(:son).should be_a(Son)
+			
+		end
+		
+		it "can get backreferences of a type" do
+			
+			@son.backreferences(GrandDad).each do |s|
+				s.should be_a(GrandDad)
+			end
+			
+		end
+		
+		it "can dereference itself" do
+			
+			@dad.dereference_from_backreferences
+			GrandDad.find("gramps").daddies.count.should eq(0)
+			
+		end
+		
+		it "can delete items from a collection" do
+			
+			@dad.sons.delete(@sonny)
+			@dad.sons.find(son_id: "sonny").first.should be_a(NilClass)
+			@dad.sons.count.should eq(1)
+			
+			@dad.delete_child(@son)
+			@dad.get(:sons).count.should eq(0)
+			
+		end
+		
+		it "can delete a collection" do
+			
+			@dad.sons.remove!
+			@dad.collections.keys.should_not include(:sons)
+			@son.remove_collection!(:grand_sons)
+			@son.collections.keys.should_not include(:grand_sons)
+			
+		end
+		
+		it "retrieves via index" do
+			
+			5.times do
+				@dad << Son.create
+			end
+			
+			# @dad.sons.indexed(:created_at,3,true).count.should eq(3)
+			
+			Son.indexed(:created_at,3,true).count.should eq(3)
+			
+		end
+		
+		it "can collect on classes themselves" do
+			
+			5.times do
+				Daddy << Son.create
+			end
+			
+			Daddy.get(:sons).should be_a(Seabright::Collection)
+			Daddy.get(:sons).count.should eq(5)
+			Daddy.get(:son).should be_a(Son)
+			Daddy.delete_child(Daddy.get(:son))
+			Daddy.get(:sons).count.should eq(4)
+			# Daddy.get(:sons).indexed(:created_at,3,true).count.should eq(3)
+			
+		end
+		
+	end
+end