redis_object 1.0 → 1.1

data/.coveralls.yml

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

data/.gitignore

@@ -1,4 +1,6 @@
 *.gem
 .bundle
+.DS_Store
 Gemfile.lock
 pkg/*
+coverage/

data/.travis.yml

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

data/Gemfile

@@ -1,4 +1,8 @@
 source "http://rubygems.org"
 
+gem 'rake'
+gem 'rspec'
+gem 'coveralls', require: false
+
 # Specify your gem's dependencies in redis_object.gemspec
 gemspec

data/README.markdown

@@ -1,14 +1,20 @@
 # RedisObject
 RedisObject is a fast and simple-to-use object persistence layer for Ruby.
 
+[![Build Status](https://travis-ci.org/remotezygote/RedisObject.png?branch=master)](https://travis-ci.org/remotezygote/RedisObject)
+[![Coverage Status](https://coveralls.io/repos/remotezygote/RedisObject/badge.png?branch=master)](https://coveralls.io/r/remotezygote/RedisObject?branch=master)
+
 ## Prerequisites
-You'll need [Redis](http://redis.io).
+You'll need [Redis](http://redis.io). Other storage adapters are in the works. Maybe.
 
 
 ## Installation
-It's hosted on [rubygems.org][rubygems].
 
-	sudo gem install redis_object
+	gem install redis_object
+
+Or, you can add it to your Gemfile:
+
+	gem 'redis_object'
 
 
 ## Usage
@@ -51,7 +57,7 @@ end
 ## 'Collections'
 Object relationships are stored in collections of objects attached to other objects. To 'collect' an object onto another, you simply call `reference` to reference the objects (also aliased to the concat operator `<<`).
 
-Collections are automatically created, and can be access by their plural, lower-case name to gather all of the items in a collection (returns and Enumerable `Collection` object), or by its singular lower-case name to just get one somewhat randomly (useful for 1 -> 1 style relationships).
+Collections are automatically created, and can be access by their plural, lower-case name to gather all of the items in a collection (returns an Enumerable `Collection` object), or by its singular lower-case name to just get one somewhat randomly (useful for 1 -> 1 style relationships).
 
 Example:
 
@@ -82,19 +88,19 @@ john.address
 # }
 ```
 
-You may also notice that the type of object, its basic storage key, and some timestamps are also automatically created and updated appropriately.
+You may notice that the type of object, its basic storage key, and some timestamps are automatically created and updated appropriately.
 
 It is important to note that collections inherit any indices of its underlying object type. See Indices below for examples.
 
 ## Types
 A few types of data can be specified for certain fields. The types supported are:
 
-Date
-Number
-Float
-Bool
-Array
-JSON (store any data that can be JSON-encoded - it will be automatically encoded/decoded when stored/accessed)
+* Date
+* Number
+* Float
+* Bool
+* Array
+* JSON (store any data that can be JSON-encoded - it will be automatically encoded/decoded when stored/accessed)
 
 These types are also used for scoring when keeping field indices. If no type is specified, String is used, and no scoring is possible at this time.
 
@@ -113,7 +119,7 @@ john.verified # false
 
 TODO: Add verified? and verified! -style methods automagically for boolean fields.
 
-You can also add your own custom types by defining filter methods for getting and setting a field, and can also define a scoring function if you would like to index fields of the type.
+You can add your own custom types by defining filter methods for getting and setting a field, and can define a scoring function if you would like to index fields of your type.
 
 Example:
 
@@ -148,7 +154,7 @@ end
 TODO: Make defining custom formats easier - no need to define class methods for this - could have helper function for it like `custom_format :bool, :get => :format_boolean` or similar.
 
 ## Indices
-Any field that can be scored can store a sidecar index by that score. These indices can also be used to index items in a collection (internally, it is a simple Redis set intersection, so it is very fast). Timestamps are indexed by default for any object, so out of the box you can do:
+Any field that can be scored can store a sidecar index by that score. These indices can be used to index items in a collection (internally, it is a simple Redis set intersection, so it is very fast). Timestamps are indexed by default for any object, so out of the box you can do:
 
 ```ruby
 Person.indexed(:created_at) # all Person objects, oldest first
@@ -160,11 +166,14 @@ Person.indexed(:updated_at, -1, true) do |person|
 end
 ```
 
-Accessing indexed items always returns an Enumerator, so first/last/each/count/etc. are always usable and will access items only when iterated.
+Accessing indexed items always returns an Enumerator, so first/last/each/count/etc. are usable anywhere and will access objects only when iterated.
+
+## Named Views
+`TODO: Add some damn View documentation.`
 
 ## Links
 Redis: [http://redis.io](http://redis.io)  
 RedisObject Code: [https://github.com/remotezygote/RedisObject](https://github.com/remotezygote/RedisObject)  
 
 
-[rubygems]: http://rubygems.org/gems/redis_object
+[rubygems]: http://rubygems.org/gems/redis_object

data/Rakefile

@@ -1,2 +1,10 @@
 require 'bundler'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new do |t|
+	t.pattern = './spec/*_spec.rb'
+end
+
 Bundler::GemHelper.install_tasks

data/lib/redis_object.rb

@@ -4,7 +4,9 @@ require 'yajl'
 
 require "redis_object/storage"
 
+require "redis_object/ext/script_cache"
 require "redis_object/base"
+require "redis_object/inheritance_tracking"
 require "redis_object/storage"
 require "redis_object/keys"
 require "redis_object/types"
@@ -12,20 +14,28 @@ require "redis_object/defaults"
 require "redis_object/collection"
 require "redis_object/indices"
 require "redis_object/timestamps"
-require "redis_object/history"
+require "redis_object/experimental/history"
+require "redis_object/ext/views"
+require "redis_object/ext/view_caching"
 require "redis_object/ext/triggers"
+require "redis_object/ext/filters"
 require "redis_object/ext/benchmark"
 
 module Seabright
 	class RedisObject
 		
+		include Seabright::Filters
 		include Seabright::ObjectBase
+		include Seabright::InheritanceTracking
+		include Seabright::CachedScripts
 		include Seabright::Storage
 		include Seabright::Keys
 		include Seabright::Types
 		include Seabright::DefaultValues
 		include Seabright::Collections
 		include Seabright::Indices
+		include Seabright::Views
+		include Seabright::ViewCaching
 		include Seabright::Timestamps
 		include Seabright::History
 		include Seabright::Triggers

data/lib/redis_object/base.rb

@@ -3,11 +3,11 @@ module Seabright
 		
 		def initialize(ident={})
 			if ident && (ident.class == String || (ident.class == Symbol && (ident = ident.to_s)))# && ident.gsub!(/.*:/,'') && ident.length > 0
-				load(ident)
+				load(ident.dup)
 			elsif ident && ident.class == Hash
 				ident[id_sym] ||= generate_id
 				if load(ident[id_sym])
-					mset(ident)
+					mset(ident.dup)
 				end
 			end
 			self
@@ -18,33 +18,17 @@ module Seabright
 		end
 		
 		def generate_id
-			v = new_id
-			while self.class.exists?(v) do
-				puts "[RedisObject] Collision at id: #{v}" if Debug.verbose?
-				v = new_id
-			end
-			puts "[RedisObject] Reserving key: #{v}" if Debug.verbose?
-			reserve(v)
-			v
+			self.class.generate_id
 		end
 		
 		def reserve(k)
-			store.set(reserve_key(k),Time.now.to_s)
+			self.class.reserve(k)
 		end
 		
 		def to_json
 			Yajl::Encoder.encode(actual)
 		end
 		
-		def dump
-			require "utf8_utils"
-			out = ["puts \"Creating: #{id}\""]
-			s_id = id.gsub(/\W/,"_")
-			out << "a#{s_id} = #{self.class.cname}.new(#{actual.to_s.tidy_bytes})"
-			out << "a#{s_id}.save"
-			out.join("\n")
-		end
-		
 		def id
 			@id || get(id_sym) || set(id_sym, generate_id)
 		end
@@ -58,7 +42,7 @@ module Seabright
 			set(:class, self.class.name)
 			set(id_sym,id.gsub(/.*:/,''))
 			set(:key, key)
-			store.sadd(self.class.cname.pluralize, key)
+			store.sadd(self.class.plname, key)
 			store.del(reserve_key)
 		end
 		
@@ -79,7 +63,7 @@ module Seabright
 		def dereference_all!
 			
 		end
-		
+
 		def raw
 			store.hgetall(hkey).inject({}) {|acc,(k,v)| acc[k.to_sym] = enforce_format(k,v); acc }
 		end
@@ -87,74 +71,163 @@ module Seabright
 		alias_method :actual, :raw
 		
 		def get(k)
-			store.hget(hkey, k.to_s)
+			cached_hash_values[k.to_s] ||= Proc.new {|key|
+				if v = store.hget(hkey, key.to_s)
+					define_setter_getter(key)
+				end
+				v
+			}.call(k)
+		end
+		
+		def [](k)
+			get(k)
 		end
-		alias_method :[], :get
 		
 		def is_set?(k)
 			store.hexists(hkey, k.to_s)
 		end
 		
 		def mset(dat)
-			# dat.each do |k,v|
-			# 	set(k,v)
-			# end
 			store.hmset(hkey, *(dat.inject([]){|acc,(k,v)| acc + [k,v] }))
+			cached_hash_values.merge!(dat)
+			dat.each do |k,v|
+				define_setter_getter(k)
+			end
 			dat
 		end
 		
+		def define_setter_getter(key)
+			define_access(key) do
+				get(key)
+			end
+			define_access("#{key.to_s}=") do |val|
+				set(key,val)
+			end
+		end
+		
+		def undefine_setter_getter(key)
+			undefine_access(key)
+			undefine_access("#{key.to_s}=")
+		end
+		
 		def set(k,v)
-			store.hset(hkey, k.to_s.gsub(/\=$/,''), v)
+			store.hset(hkey, k.to_s, v.to_s)
+			cached_hash_values[k.to_s] = v
+			define_setter_getter(k)
 			v
 		end
-		alias_method :[]=, :set
 		
-		def unset(k)
-			store.hdel(hkey, k.to_s)
+		def setnx(k,v)
+			if success = store.hsetnx(hkey, k.to_s, v.to_s)
+				cached_hash_values[k.to_s] = v
+				define_setter_getter(k)
+			end
+			success
+		end
+		
+		def []=(k,v)
+			set(k,v)
 		end
 		
 		def unset(*k)
-			store.hdel(hkey,*k)
+			store.hdel(hkey, k.map(&:to_s))
+			k.each do |ky|
+				cached_hash_values.delete ky.to_s
+				undefine_setter_getter(ky)
+			end
 		end
-		# alias_method :delete, :unset
 		
 		private
 		
+		SetPattern = /=$/.freeze
+		
 		def method_missing(sym, *args, &block)
-			sym.to_s =~ /=$/ ? set(sym,*args) : get(sym)
+			super if sym == :class
+			if sym.to_s =~ SetPattern
+				return super if args.size > 1
+				set(sym.to_s.gsub(SetPattern,'').to_sym,*args)
+			else
+				return super if !args.empty?
+				get(sym)
+			end
+		end
+		
+		def id_sym(cls=self.class.cname)
+			"#{cls.split('::').last.downcase}_id".to_sym
 		end
 		
-		def id_sym(cls=nil)
-			"#{(cls || self.class.cname).split('::').last.downcase}_id".to_sym
+		def load_all_hash_values
+			@cached_hash_values = store.hgetall(hkey)
+			cached_hash_values.keys.dup.each do |key|
+				next if key == "class"
+				define_setter_getter(key)
+			end
+		end
+		
+		def cached_hash_values
+			@cached_hash_values ||= {}
+		end
+		
+		def define_access(key,&block)
+			return if self.respond_to?(key.to_sym)
+			metaclass = class << self; self; end
+			metaclass.send(:define_method, key.to_sym, &block)
+		end
+		
+		def undefine_access(key)
+			return unless self.respond_to?(key.to_sym)
+			metaclass = class << self; self; end
+			metaclass.send(:remove_method, key.to_sym)
 		end
 		
 		module ClassMethods
 			
+			def generate_id
+				v = new_id
+				while exists?(v) do
+					puts "[RedisObject] Collision at id: #{v}" if Debug.verbose?
+					v = new_id
+				end
+				puts "[RedisObject] Reserving key: #{v}" if Debug.verbose?
+				reserve(v)
+				v
+			end
+			
+			def reserve(k)
+				store.set(reserve_key(k),Time.now.to_s)
+			end
+			
 			def new_id(complexity = 8)
 				rand(36**complexity).to_s(36)
 			end
 			
 			def cname
-				@cname = self.name.split('::').last
+				self.name
 			end
 			
 			def plname
-				@plname ||= cname.pluralize
+				cname.pluralize
 			end
 			
 			def all
 				Enumerator.new do |y|
 					store.smembers(plname).each do |member|
-						if a = RedisObject.find_by_key(hkey(member))
+						if a = find_by_key(hkey(member))
 							y << a
 						else
 							puts "[#{name}] Object listed but not found: #{member}" if DEBUG
-							# store.srem(plname,member)
+							store.srem(plname,member)
 						end
 					end
 				end
 			end
 			
+			def recollect!
+				store.keys("#{name}:*_h").each do |ky|
+					store.sadd(plname,ky.gsub(/_h$/,''))
+				end
+			end
+			
 			def first
 				if m = store.smembers(plname)
 				 self.grab(m.first)
@@ -169,25 +242,95 @@ module Seabright
 				end
 			end
 			
+			RedisObject::ScriptSources::Matcher = "local itms = redis.call('SMEMBERS',KEYS[1])
+				local out = {}
+				local val
+				local pattern
+				for i, v in ipairs(itms) do
+					val = redis.call('HGET',v..'_h',ARGV[1])
+					if ARGV[2]:find('^pattern:') then
+						pattern = ARGV[2]:gsub('^pattern:','')
+						if val:match(pattern) ~= nil then
+							table.insert(out,itms[i])
+						end
+					else
+						if val == ARGV[2] then
+							table.insert(out,itms[i])
+						end
+					end
+				end
+				return out".gsub(/\t/,'').freeze
+			
+			RedisObject::ScriptSources::MultiMatcher = "local itms = redis.call('SMEMBERS',KEYS[1])
+				local out = {}
+				local matchers = {}
+				local matcher = {}
+				local mod
+				for i=1,#ARGV do
+					mod = i % 2
+					if mod == 1 then
+						matcher[1] = ARGV[i]
+					else
+						matcher[2] = ARGV[i]
+						table.insert(matchers,matcher)
+						matcher = {}
+					end
+				end
+				local val
+				local good
+				local pattern
+				for i, v in ipairs(itms) do
+					good = true
+					for n=1,#matchers do
+						val = redis.call('HGET',v..'_h',matchers[n][1])
+						if val then
+							if matchers[n][2]:find('^pattern:') then
+								pattern = matchers[n][2]:gsub('^pattern:','')
+								if val:match(pattern) then
+									good = good
+								else
+									good = false
+								end
+							else
+								if val ~= matchers[n][2] then
+									good = false
+								end
+							end
+						else
+							good = false
+						end
+					end
+					if good == true then
+						table.insert(out,itms[i])
+					end
+				end
+				return out".gsub(/\t/,'').freeze
+			
 			def match(pkt)
 				Enumerator.new do |y|
-					each do |i|
-						if pkt.map {|hk,va| i.get(hk)==va }.all?
-							y << i
-						end
+					run_script(pkt.keys.count > 1 ? :MultiMatcher : :Matcher,[plname],pkt.flatten.map{|i| i.is_a?(Regexp) ? convert_regex_to_lua(i) : i.to_s }).each do |k|
+						y << find(k)
 					end
 				end
 			end
 			
+			def convert_regex_to_lua(reg)
+				"pattern:#{reg.source.gsub("\\","")}"
+			end
+			
 			def grab(ident)
-				if ident.class == String
-					return store.exists(self.hkey(ident)) ? self.new(ident) : nil
-				elsif ident.class == Hash
+				case ident
+				when String, Symbol
+					return store.exists(self.hkey(ident.to_s)) ? self.new(ident.to_s) : nil
+				when Hash
 					return match(ident)
 				end
 				nil
 			end
-			alias_method :find, :grab
+			
+			def find(ident)
+				grab(ident)
+			end
 			
 			def exists?(k)
 				store.exists(self.hkey(k)) || store.exists(self.reserve_key(k))
@@ -199,13 +342,13 @@ module Seabright
 				obj
 			end
 			
-			def dump
-				out = []
-				each do |obj|
-					out << obj.dump
-				end
-				out.join("\n")
-			end
+			# def dump
+			# 	out = []
+			# 	each do |obj|
+			# 		out << obj.dump
+			# 	end
+			# 	out.join("\n")
+			# end
 			
 			def use_dbnum(db=0)
 				@dbnum = db
@@ -217,8 +360,7 @@ module Seabright
 			
 			def find_by_key(k)
 				if store.exists(k) && (cls = store.hget(k,:class))
-					o_id = store.hget(k,id_sym(cls))
-					return deep_const_get(cls.to_sym).new(o_id)
+					return deep_const_get(cls.to_sym).new(store.hget(k,id_sym(cls)))
 				end
 				nil
 			end
@@ -244,8 +386,16 @@ module Seabright
 				true
 			end
 			
-			def id_sym(cls=nil)
-				"#{(cls || cname).split('::').last.downcase}_id".to_sym
+			def id_sym(cls=cname)
+				"#{cls.split('::').last.downcase}_id".to_sym
+			end
+			
+			def describe
+				all_keys.inject({}) do |acc,(k,v)|
+					acc[k.to_sym] ||= [:string, 0]
+					acc[k.to_sym][1] += 1
+					acc
+				end
 			end
 			
 		end
@@ -255,4 +405,4 @@ module Seabright
 		end
 		
 	end
-end
+end