redis_assist 0.1.0

data/lib/redis_assist/base.rb

@@ -0,0 +1,383 @@
+module RedisAssist
+  class Base
+    class << self
+
+      def attr_persist(name, opts={})
+        persisted_attrs[name] = opts
+
+        if opts[:as].eql?(:list)
+          define_list(name)
+        elsif opts[:as].eql?(:hash)
+          define_hash(name)
+        else
+          define_field(name)
+        end
+      end
+
+      def find(ids, opts={})
+        ids.is_a?(Array) ? find_by_ids(ids, opts) : find_by_id(ids, opts)
+      end
+  
+      # Deprecated finds
+      def find_by_id(id, opts={})
+        raw_attributes = load_attributes(id)
+        return nil unless raw_attributes[id]
+        obj = new(id: id, raw_attributes: raw_attributes[id])
+        (obj.deleted? && !opts[:deleted].eql?(true)) ? nil : obj
+      end
+  
+      def find_by_ids(ids, opts={})
+        attrs = load_attributes(*ids)
+        raw_attributes = attrs
+        ids.each_with_object([]) do |id, instances| 
+          instance = new(id: id, raw_attributes: raw_attributes[id]) unless raw_attributes[id].nil?
+          instances << instance if instance && (!instance.deleted? || opts[:deleted].eql?(true))
+        end
+      end
+  
+      def create(attrs={})
+        roll = new(attrs)
+        roll.save ? roll : false
+      end
+
+      def exists?(id)
+        redis.exists(key_for(id, :attributes))      
+      end
+
+      def update(id, params={})
+        record = find(id)
+        return false unless record
+
+        redis.multi do
+          params.each do |attr, val|
+            if persisted_attrs.include?(attr)
+              if fields.keys.include? attr
+                transform(:to, attr, val)
+                redis.hset(key_for(id, :attributes), attr, transform(:to, attr, val)) 
+              end
+
+              if lists.keys.include? attr
+                redis.del(key_for(id, attr)) 
+                redis.rpush(key_for(id, attr), val) unless val.empty?
+              end
+
+              if hashes.keys.include? attr
+                redis.del(key_for(id, attr))
+                redis.hmset(key_for(id, attr), *hash_to_redis(val))
+              end
+            end
+          end
+        end
+
+        record.send(:invoke_callback, :after_update)
+      end
+
+      def transform(direction, attr, val)
+        transformer = RedisAssist.transforms[persisted_attrs[attr][:as]]
+
+        if transformer
+          transformer.transform(direction, val)
+        else
+          val || persisted_attrs[attr][:default]
+        end
+      end
+
+      def fields
+        persisted_attrs.select{|k,v| !(v[:as].eql?(:list) || v[:as].eql?(:hash)) }
+      end
+  
+      def lists 
+        persisted_attrs.select{|k,v| v[:as].eql?(:list) }
+      end
+  
+      def hashes 
+        persisted_attrs.select{|k,v| v[:as].eql?(:hash) }
+      end
+
+      # TODO: Attribute class
+      def persisted_attrs
+        @persisted_attrs ||= {}
+      end
+
+      def key_for(id, attribute)
+        "#{key_prefix}:#{id}:#{attribute}"
+      end
+  
+      def key_prefix(val=nil)
+        return self.key_prefix = val if val
+        return @key_prefix if @key_prefix
+        return self.key_prefix = StringHelper.underscore(name)
+      end
+  
+      def key_prefix=(val)
+        @key_prefix = val
+      end
+   
+      def redis
+        RedisAssist::Config.redis_client
+      end
+  
+      def load_attributes(*ids)
+        future_attrs  = {}
+        attrs         = {}
+
+        # Load all the futures into an organized Hash
+        redis.pipelined do |pipe|
+          ids.each_with_object(future_attrs) do |id, futures|
+            future_lists  = {}
+            future_hashes = {}
+            future_fields = nil
+  
+            lists.each do |name, opts|
+              future_lists[name]  = pipe.lrange(key_for(id, name), 0, -1)
+            end
+  
+            hashes.each do |name, opts|
+              future_hashes[name] = pipe.hgetall(key_for(id, name))
+            end
+  
+            future_fields = pipe.hmget(key_for(id, :attributes), fields.keys)
+
+            futures[id] = { lists: future_lists, hashes: future_hashes, fields: future_fields } 
+          end
+        end
+
+        # Remove the empty futures
+        future_attrs = ids.each_with_object({}) do |id, obj|
+           obj[id] = future_attrs[id] unless future_attrs[id][:fields].value.select{|v| !v.nil? }.empty?
+        end
+
+        # Map futures to attributes
+        future_attrs.each_with_object(attrs) do |kv, obj|
+          lists       = kv[1][:lists].each_with_object({}){|kv,obj| obj[kv[0]] = kv[1].value unless kv[1].value.nil? }
+          hashes      = kv[1][:hashes].each_with_object({}){|kv,obj| obj[kv[0]] = kv[1].value unless kv[1].value.nil?}
+          fields      = Hash[*self.fields.keys.zip(kv[1][:fields].value).flatten] 
+          obj[kv[0]]  = { lists: lists, hashes: hashes, fields: fields }
+        end
+
+        attrs
+      end
+      
+      def hash_to_redis(obj)
+        obj.each_with_object([]) {|kv,args| args<<kv[0]<<kv[1] }
+      end
+
+      private
+
+      def define_list(name)
+        define_method(name) do
+          opts = self.class.persisted_attrs[name]
+          self.send("#{name}=", opts[:default]) if !lists[name] && opts[:default]
+          lists[name]
+        end
+  
+        define_method("#{name}=") do |val|
+          raise "RedisAssist: tried to store a #{val.class.name} as Array" unless val.is_a?(Array)
+          lists[name] = val
+        end
+      end
+
+      def define_hash(name)
+        define_method(name) do
+          opts = self.class.persisted_attrs[name]
+          self.send("#{name}=", opts[:default]) if !hashes[name] && opts[:default]
+          hashes[name]
+        end
+  
+        define_method("#{name}=") do |val|
+          raise "RedisAssist: tried to store a #{val.class.name} as Hash" unless val.is_a?(Hash)
+          hashes[name] = val
+        end
+      end
+
+      def define_field(name)
+        define_method(name) do 
+          self.class.transform(:from, name, attributes[name])
+        end
+  
+        define_method("#{name}=") do |val| 
+          attributes[name] = self.class.transform(:to, name, val)
+        end
+      end
+    end
+  
+    attr_accessor :attributes
+    attr_reader :id, :errors
+  
+    def initialize(attrs={})
+      @attributes = {}
+      self.lists  = {}
+      self.hashes = {}
+      self.errors = []
+  
+      if attrs[:id]
+        self.id = attrs[:id]
+        load_attributes(attrs[:raw_attributes])
+      end
+
+      return self if id 
+  
+      self.new_record = true
+  
+      invoke_callback(:on_load)
+  
+      self.class.persisted_attrs.keys.each do |name|
+        send("#{name}=", attrs[name]) if attrs[name]
+        attrs.delete(name)
+      end
+  
+      raise "RedisAssist: #{self.class.name} does not support fields: #{attrs.keys.join(', ')}" if attrs.length > 0
+    end
+  
+    def saved?
+      !!(new_record?.eql?(false) && id)
+    end
+  
+    def save
+      return false  unless valid? 
+  
+      invoke_callback(:before_update) unless new_record?
+      invoke_callback(:before_create) if new_record?
+      invoke_callback(:before_save)
+  
+      # Assing the record with the next available ID
+      self.id = generate_id
+
+      redis.multi do
+        # build the arguments to pass to redis hmset
+        # and insure the fields are explicitely declared
+        attribute_args = hash_to_redis(attributes)
+ 
+        redis.hmset(key_for(:attributes), *attribute_args)
+  
+        lists.each do |name, val|
+          redis.del(key_for(name))
+          redis.rpush(key_for(name), val) if val && !val.empty?
+        end
+  
+        hashes.each do |name, val|
+          hash_as_args = hash_to_redis(val)
+          redis.hmset(key_for(name), *hash_as_args)
+        end
+      end
+
+      invoke_callback(:after_save)
+      invoke_callback(:after_update) unless new_record?
+      invoke_callback(:after_create) if new_record?
+  
+      self
+    end
+
+    def save!
+      raise "RedisAssist: save! failed with errors" unless save
+      self
+    end
+  
+    def valid?
+      invoke_callback(:before_validation)
+      validate
+      errors.empty?
+    end
+  
+    def validate; end
+  
+    # TODO: should this be a redis-assist feature?
+    def deleted?
+      return false unless respond_to?(:deleted_at)
+      deleted_at && deleted_at.is_a?(Time)
+    end
+  
+    def delete
+      if respond_to?(:deleted_at)
+        self.deleted_at = Time.now.to_f if respond_to?(:deleted_at)
+        save
+      else
+        redis.pipelined do |pipe|
+          pipe.del(key_for(:attributes))
+          lists.merge(hashes).each do |name|
+            pipe.del(key_for(name))
+          end
+        end
+      end
+
+      invoke_callback(:after_delete)
+      self
+    end
+  
+    def new_record?
+      !!new_record
+    end
+  
+    def redis
+      self.class.redis
+    end
+  
+    def add_error(field, message)
+      errors << { field => message }
+    end
+  
+    protected 
+  
+  
+    attr_writer :id, :errors
+    attr_accessor :lists, :hashes, :new_record
+  
+    def _on_load; end
+  
+    def _before_validation
+      self.errors = []
+    end
+  
+    def _before_create
+      self.created_at = Time.now.to_f if respond_to?(:created_at)
+    end
+ 
+    def _before_update
+      self.updated_at = Time.now.to_f if respond_to?(:updated_at)
+    end
+ 
+    def _after_delete
+      self.deleted_at = Time.now.to_f if respond_to?(:deleted_at)
+    end
+
+    def _after_create
+      self.new_record = false
+    end
+  
+    def _before_save; end
+    def _after_save; end
+    def _after_update; end
+  
+  
+    private
+  
+  
+    def invoke_callback(callback)
+      send("_#{callback}")
+      send(callback) if respond_to? callback
+    end
+  
+    def generate_id
+      redis.incr("#{self.class.key_prefix}:id_sequence")
+    end
+  
+    def key_for(attribute)
+      self.class.key_for(id, attribute)
+    end
+  
+    def load_attributes(raw_attributes)
+      return nil unless raw_attributes
+      load_response   = self.class.load_attributes(id)
+      self.lists      = load_response[id][:lists] 
+      self.hashes     = load_response[id][:hashes] 
+      self.attributes = load_response[id][:fields]
+      self.new_record = false
+    end
+  
+    ##
+    # This converts a hash into args for a redis hmset
+    def hash_to_redis(obj)
+      self.class.hash_to_redis(obj)
+    end
+  end
+end

data/lib/redis_assist/config.rb

@@ -0,0 +1,15 @@
+module RedisAssist
+  class Config
+    class << self
+      def redis_client
+        return @redis_client if @redis_client
+        redis_config      = { :host => '127.0.0.1', :driver => :hiredis } 
+        self.redis_client = Redis.new(redis_config) 
+      end
+
+      def redis_client=(val)
+        @redis_client = val
+      end
+    end
+  end
+end

data/lib/redis_assist/transform.rb

@@ -0,0 +1,37 @@
+module RedisAssist
+  def self.register_transform(transform)
+    transforms[transform.key.to_sym] = transform
+  end
+
+  def self.transforms
+    @transforms ||= {}
+  end
+
+  class Transform
+    def self.inherited(base)
+      base.extend ClassMethods
+      RedisAssist.register_transform base
+    end
+
+    module ClassMethods
+      def key
+        StringHelper.underscore(name).gsub(/_transform$/, '').to_sym
+      end
+
+      def from(val)
+        val
+      end
+
+      def to(val)
+        val
+      end
+
+      def transform(direction, val)
+        case direction.to_sym
+        when :to    then to(val)
+        when :from  then from(val)
+        end
+      end
+    end
+  end
+end

data/lib/redis_assist/transforms/boolean_transform.rb

@@ -0,0 +1,5 @@
+class BooleanTransform < RedisAssist::Transform
+  def self.from(val)
+    val.eql?('true') || val.eql?(true)
+  end
+end

data/lib/redis_assist/transforms/float_transform.rb

@@ -0,0 +1,5 @@
+class FloatTransform < RedisAssist::Transform
+  def self.from(val)
+    val.to_f
+  end
+end

data/lib/redis_assist/transforms/integer_transform.rb

@@ -0,0 +1,5 @@
+class IntegerTransform < RedisAssist::Transform
+  def self.from(val)
+    val.to_i
+  end
+end

data/lib/redis_assist/transforms/json_transform.rb

@@ -0,0 +1,9 @@
+class JsonTransform < RedisAssist::Transform
+  def self.to(val)
+    JSON.generate(val)
+  end
+
+  def self.from(val)
+    JSON.parse(val)
+  end
+end

data/lib/redis_assist/transforms/time_transform.rb

@@ -0,0 +1,9 @@
+class TimeTransform < RedisAssist::Transform
+  def self.to(val)
+    val.to_f
+  end
+
+  def self.from(val)
+    (val && !val.eql?('')) ? Time.at(val.to_f) : nil
+  end
+end

data/lib/redis_assist/version.rb

@@ -0,0 +1,3 @@
+module RedisAssist
+  VERSION = '0.1.0' unless defined?(::RedisAssist::VERSION)
+end

data/lib/redis_assist.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+
+require 'time'
+require 'redis'
+require 'uuid'
+require 'json'
+require 'redis_assist/config'
+require 'redis_assist/transform'
+require 'redis_assist/base'
+
+# == Setup & Configuration
+# RedisAssist depends on the redis-rb gem to communicate with redis.
+# To configure your redis connection simply pass `RedisAssist` a `Redis` client instance.
+#   RedisAssist::Config.redis_client = Redis.new(redis_config)
+module RedisAssist
+  module StringHelper
+    def self.underscore(str)
+      str.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end
+
+# require all transforms
+Dir["#{File.dirname(__FILE__)}/redis_assist/transforms/*.rb"].each {|file| require file }
+

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: redis_assist
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Tyler Love
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70264080458040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70264080458040
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: &70264080457500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *70264080457500
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: &70264080456980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *70264080456980
+- !ruby/object:Gem::Dependency
+  name: base62
+  requirement: &70264080456440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *70264080456440
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70264080455960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70264080455960
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70264080455360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: *70264080455360
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70264080454760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *70264080454760
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70264080453820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: *70264080453820
+description: Redis persistant object oriented programming
+email:
+- t@tylr.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/redis_assist/base.rb
+- lib/redis_assist/config.rb
+- lib/redis_assist/transform.rb
+- lib/redis_assist/transforms/boolean_transform.rb
+- lib/redis_assist/transforms/float_transform.rb
+- lib/redis_assist/transforms/integer_transform.rb
+- lib/redis_assist/transforms/json_transform.rb
+- lib/redis_assist/transforms/time_transform.rb
+- lib/redis_assist/version.rb
+- lib/redis_assist.rb
+homepage: http://github.com/tylr/redis-assist
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: redis_assist
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Persistant object oriented programming with redis
+test_files: []
+has_rdoc: