redis_object 0.5.0

data/.coveralls.yml

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

data/.gitignore

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

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

@@ -0,0 +1,179 @@
+# 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). Other storage adapters are in the works. Maybe.
+
+
+## Installation
+
+	gem install redis_object
+
+Or, you can add it to your Gemfile:
+
+	gem 'redis_object'
+
+
+## Usage
+###  Simple Example
+```ruby
+class Thing < RedisObject
+  def name
+    "#{first_name} #{last_name}"
+  end
+  def name=(new_name)
+    first, last = new_name.split(" ")
+    set(:first_name,first)
+    set(:last_name,last)
+  end
+end
+a = Thing.create("an_id")
+a.name = "Testy Testerton"
+b = Thing.create({:first_name => "Testy", :last_name => "Testerton"})
+```
+
+### Config
+You can configure the storage adapter by sending a packet of commands to `configure_store` like:
+
+```ruby
+RedisObject.configure_store({:db: 2})
+```
+
+The default storage adapter is `Redis`. The above config will connect to Redis on localhost on the default port (6379), but will `select` database number 2.
+
+Or, you can configure multiple stores to use within an app by passing a second parameter to name the store (default is 'general')
+
+```ruby
+RedisObject.configure_store({adapter: "Redis", :db: 4, :path: "/var/run/redis.sock"}, :message_queue)
+
+class Message < RedisObject
+  use_store :message_queue
+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 an Enumerable `Collection` object), or by its singular lower-case name to just get one somewhat randomly (useful for 1 -> 1 style relationships).
+
+Example:
+
+```ruby
+class Person < RedisObject; end
+class Address < RedisObject; end
+john = Person.create("john")
+john << Address.create({
+  :street => "123 Main St.",
+  :city => "San Francisco",
+  :state => "CA",
+  :zip => "12345"
+})
+
+john.addresses
+# ["Address:john"]
+john.address 
+# {
+#   :address_id => "john",
+#   :street => "123 Main St.",
+#   :city => "San Francisco",
+#   :state => "CA",
+#   :zip => "12345",
+#   :class=>"Address",
+#   :key=>"Address:john",
+#   :created_at=>Wed, 12 Dec 2012 16:49:26 -0800,
+#   :updated_at=>Wed, 12 Dec 2012 16:49:26 -0800
+# }
+```
+
+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)
+
+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.
+
+Setting the type of a field is super easy:
+
+```ruby
+class Person < RedisObject
+  bool :verified
+  json :meta
+end
+
+john = Person.create("john")
+john.meta = {:external_id => "123456", :number => 123}
+john.verified # false
+```
+
+TODO: Add verified? and verified! -style methods automagically for boolean fields.
+
+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:
+
+```ruby
+class Person < RedisObject
+
+  def format_boolean(val)
+    val=="true"
+  end
+
+  def save_boolean(val)
+    val ? "true" : "false"
+  end
+
+  def score_boolean(val)
+    val ? 1 : 0
+  end
+
+  class << self
+    def bool(k)
+      field_formats[k] = :format_boolean
+      save_formats[k] = :save_boolean
+      score_formats[k] = :score_boolean
+    end
+    alias_method :boolean, :bool
+
+  end
+
+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 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
+Person.indexed(:created_at, 1, true) # newest Person (index_field, number of items, reverse sort?)
+Person.latest # always available if timestamps are on - most recently created object of type
+john.addresses.indexed(:created_at, 3, true) # john's 3 most recent addresses
+Person.indexed(:updated_at, -1, true) do |person|
+  # iterate through Person objects in order of update times, most recent first
+end
+```
+
+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

data/Rakefile

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

@@ -0,0 +1,47 @@
+require 'active_support/inflector'
+require 'active_support/core_ext/date_time/conversions'
+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"
+require "redis_object/defaults"
+require "redis_object/collection"
+require "redis_object/indices"
+require "redis_object/timestamps"
+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
+		include Seabright::Benchmark
+		
+	end
+end
+
+::RedisObject = Seabright::RedisObject

data/lib/redis_object/base.rb

@@ -0,0 +1,408 @@
+module Seabright
+	module ObjectBase
+		
+		def initialize(ident={})
+			if ident && (ident.class == String || (ident.class == Symbol && (ident = ident.to_s)))# && ident.gsub!(/.*:/,'') && ident.length > 0
+				load(ident.dup)
+			elsif ident && ident.class == Hash
+				ident[id_sym] ||= generate_id
+				if load(ident[id_sym])
+					mset(ident.dup)
+				end
+			end
+			self
+		end
+		
+		def new_id(complexity = 8)
+			self.class.new_id(complexity)
+		end
+		
+		def generate_id
+			self.class.generate_id
+		end
+		
+		def reserve(k)
+			self.class.reserve(k)
+		end
+		
+		def to_json
+			Yajl::Encoder.encode(actual)
+		end
+		
+		def id
+			@id || get(id_sym) || set(id_sym, generate_id)
+		end
+		
+		def load(o_id)
+			@id = o_id
+			true
+		end
+		
+		def save
+			set(:class, self.class.name)
+			set(id_sym,id.gsub(/.*:/,''))
+			set(:key, key)
+			store.sadd(self.class.plname, key)
+			store.del(reserve_key)
+		end
+		
+		def delete!
+			store.del key
+			store.del hkey
+			store.del reserve_key
+			store.srem(self.class.plname, key)
+			# store.smembers(ref_key).each do |k|
+			# 	if self.class.find_by_key(k)
+			# 		
+			# 	end
+			# end
+			dereference_all!
+			nil
+		end
+		
+		def dereference_all!
+			
+		end
+
+		def raw
+			store.hgetall(hkey).inject({}) {|acc,(k,v)| acc[k.to_sym] = enforce_format(k,v); acc }
+		end
+		alias_method :inspect, :raw
+		alias_method :actual, :raw
+		
+		def get(k)
+			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
+		
+		def is_set?(k)
+			store.hexists(hkey, k.to_s)
+		end
+		
+		def mset(dat)
+			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, v.to_s)
+			cached_hash_values[k.to_s] = v
+			define_setter_getter(k)
+			v
+		end
+		
+		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.map(&:to_s))
+			k.each do |ky|
+				cached_hash_values.delete ky.to_s
+				undefine_setter_getter(ky)
+			end
+		end
+		
+		private
+		
+		SetPattern = /=$/.freeze
+		
+		def method_missing(sym, *args, &block)
+			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 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
+				self.name
+			end
+			
+			def plname
+				cname.pluralize
+			end
+			
+			def all
+				Enumerator.new do |y|
+					store.smembers(plname).each do |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)
+						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)
+				else
+					nil
+				end
+			end
+			
+			def each
+				all.each do |o|
+					yield o
+				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|
+					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)
+				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
+			
+			def find(ident)
+				grab(ident)
+			end
+			
+			def exists?(k)
+				store.exists(self.hkey(k)) || store.exists(self.reserve_key(k))
+			end
+			
+			def create(ident={})
+				obj = new(ident)
+				obj.save
+				obj
+			end
+			
+			# def dump
+			# 	out = []
+			# 	each do |obj|
+			# 		out << obj.dump
+			# 	end
+			# 	out.join("\n")
+			# end
+			
+			def use_dbnum(db=0)
+				@dbnum = db
+			end
+			
+			def dbnum
+				@dbnum ||= 0
+			end
+			
+			def find_by_key(k)
+				if store.exists(k) && (cls = store.hget(k,:class))
+					return deep_const_get(cls.to_sym).new(store.hget(k,id_sym(cls)))
+				end
+				nil
+			end
+			
+			def deep_const_get(const)
+				if Symbol === const
+					const = const.to_s
+				else
+					const = const.to_str.dup
+				end
+				if const.sub!(/^::/, '')
+					base = Object
+				else
+					base = self
+				end
+				const.split(/::/).inject(base) { |mod, name| mod.const_get(name) }
+			end
+			
+			def save_all
+				all.each do |obj|
+					obj.save
+				end
+				true
+			end
+			
+			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
+		
+		def self.included(base)
+			base.extend(ClassMethods)
+		end
+		
+	end
+end