redis-orm 0.0.1

data/lib/redis/orm.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../redis-orm', File.dirname(__FILE__))
+require 'active_support/core_ext'
+require 'active_model'
+require 'redis/relations'
+require 'redis/validations'
+require 'redis/orm/attributes'
+require 'redis/actions'
+
+class Redis::ORM
+  class_inheritable_accessor :serializer
+  self.serializer ||= Marshal
+  delegate :model_name, :to => "self.class"
+  delegate :connection, :to => :Redis
+  
+  extend ActiveModel::Callbacks
+  extend ActiveModel::Naming
+  include ActiveModel::Validations
+
+  define_model_callbacks :initialize
+
+  include Redis::ORM::Attributes
+  include Redis::Actions
+  include Redis::Relations
+  include Redis::Validations
+  
+  attribute :key
+  validates_uniqueness_of :key
+  
+  class << self
+    delegate :connection, :to => :Redis
+  end
+
+  def to_key
+    persisted? ? key : nil
+  end
+  
+  def to_param
+    persisted? ? File.join(model_name, key) : nil
+  end
+  
+  def persisted?
+    !new_record? && !changed?
+  end
+  
+  def initialize(attributes = {})
+    run_callbacks :initialize do
+      self.attributes = attributes
+      @previous_attributes = nil
+    end
+  end
+  
+  def transaction(&block)
+    connection.multi &block
+  end
+  
+  def ==(other)
+    other && key == other.key
+  end
+end

data/lib/redis/orm/attributes.rb

@@ -0,0 +1,65 @@
+class Redis::ORM
+  module Attributes
+    def self.included(base)
+      base.class_eval do
+        extend Redis::ORM::Attributes::ClassMethods
+        class_inheritable_hash :model_attributes
+        self.model_attributes ||= HashWithIndifferentAccess.new
+      end
+    end
+  
+    def attributes
+      @attributes ||= model_attributes.dup
+    end
+  
+    def set_unchanged!
+      @previous_attributes = attributes.dup
+    end
+
+    def attribute_names
+      @attribute_names ||= attributes.keys
+    end
+  
+    def attributes=(changed_attributes)
+      changed_attributes.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+  
+    def previous_attributes
+      # note we do NOT assign here, this is because #changed?
+      # and #new_record? rely on @previous_attributes to be nil
+      @previous_attributes || attributes.dup
+    end
+
+    def new_record?
+      @previous_attributes.nil?
+    end
+  
+    def changed?
+      new_record? || attributes != @previous_attributes
+    end
+    
+    module ClassMethods
+      def attribute_names
+        model_attributes.keys
+      end
+
+      def attribute(key, default_value = nil)
+        model_attributes.merge!({key => default_value})
+
+        define_method key do
+          attributes[key]
+        end
+
+        define_method "#{key}=" do |value|
+          if value != attributes[key]
+            attributes[key] = value
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis/orm/version.rb

@@ -0,0 +1,14 @@
+class Redis
+  class ORM
+    module Version
+      MAJOR = 0
+      MINOR = 0
+      PATCH = 1
+      PREREL = nil
+    
+      STRING = PREREL ? [MAJOR, MINOR, PATCH, PREREL].join('.') : [MAJOR, MINOR, PATCH].join('.')
+    end
+  
+    VERSION = Version::STRING
+  end
+end

data/lib/redis/relations.rb

@@ -0,0 +1,22 @@
+module Redis::Relations
+  autoload :BelongsTo, "redis/relations/belongs_to"
+  autoload :HasMany,   "redis/relations/has_many"
+  autoload :HasOne,    "redis/relations/has_one"
+  
+  def self.included(base)
+    base.class_eval do
+      class << self
+        def add_relation(name)
+          varn = "#{name}_relations"
+          class_inheritable_hash varn                       # class_inheritable_hash 'belongs_to_relations'
+          send(varn) || send("#{varn}=", {})                # self.belongs_to_relations ||= {}
+          within_save_block "save_#{name}_references"       # within_save_block 'save_belongs_to_references'
+        end
+      end
+      
+      include Redis::Relations::BelongsTo
+      include Redis::Relations::HasMany
+      include Redis::Relations::HasOne
+    end
+  end
+end

data/lib/redis/relations/belongs_to.rb

@@ -0,0 +1,51 @@
+module Redis::Relations::BelongsTo
+  def belongs_to_references
+    @belongs_to_references ||= {}
+  end
+  
+  def set_belongs_to_reference(name, a)
+    belongs_to_references[name] = a
+  end
+  
+  def get_belongs_to_reference(name)
+    if belongs_to_references.key?(name)
+      belongs_to_references[name]
+    else
+      result = self.class.find(connection.hget(belongs_to_relation_key(name), key))
+      belongs_to_references[name] = result
+    end
+  end
+  
+  def belongs_to_relation_key(name)
+    File.join("references", belongs_to_relations[name][:relation].to_s)
+  end
+  
+  def save_belongs_to_references
+    belongs_to_references.each do |relation_name, reference|
+      if reference
+        reference = reference.key
+      end
+      connection.hset(belongs_to_relation_key(relation_name), key, reference)
+    end
+  end
+  
+  def self.included(base)
+    base.class_eval do
+      add_relation :belongs_to
+      
+      class << self
+        def belongs_to(relation_name, options = {})
+          belongs_to_relations[relation_name] = options.reverse_merge({ :relation => relation_name })
+        
+          define_method relation_name do
+            get_belongs_to_reference(relation_name)
+          end
+        
+          define_method "#{relation_name}=" do |a|
+            set_belongs_to_reference(relation_name, a)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis/relations/has_many.rb

@@ -0,0 +1,60 @@
+module Redis::Relations::HasMany
+  def has_many_references
+    @has_many_references ||= {}
+  end
+  
+  def get_has_many_reference(relation_name)
+    if has_many_references.key?(relation_name)
+      has_many_references[relation_name]
+    else
+      result = connection.hget(has_many_relation_key(relation_name), key)
+      if result
+        result = serializer.load(result)
+        if result.respond_to?(:collect)
+          result = result.collect { |r| self.class.find(r) }
+        else
+          result = [find(result)]
+        end
+      else
+        result = []
+      end
+      has_many_references[relation_name] = result
+    end
+  end
+  
+  def save_has_many_references
+    has_many_references.each do |relation_name, array|
+      array = array.collect { |a| a.key }
+      connection.hset(has_many_relation_key(relation_name), key, serializer.dump(array))
+      array.each do |akey|
+        connection.hset(has_many_relation_key(relation_name), akey, key)
+      end
+    end
+  end
+  
+  def has_many_relation_key(name)
+    File.join("references", has_many_relations[name][:relation].to_s)
+  end
+  
+  def self.included(base)
+    base.class_eval do
+      add_relation :has_many
+      
+      class << self
+        def has_many(relation_name, options = {})
+          has_many_relations[relation_name] = options.reverse_merge({ :relation => relation_name })
+        
+          define_method relation_name do
+            get_has_many_reference(relation_name)
+          end
+          
+          define_method "#{relation_name}=" do |array|
+            target = get_has_many_reference(relation_name)
+            target.clear
+            target.concat array
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis/relations/has_one.rb

@@ -0,0 +1,51 @@
+module Redis::Relations::HasOne
+  def has_one_references
+    @has_one_references ||= {}
+  end
+  
+  def set_has_one_reference(relation_name, value)
+    has_one_references[relation_name] = value
+  end
+  
+  def get_has_one_reference(relation_name)
+    if has_one_references.key?(relation_name)
+      has_one_references[relation_name]
+    else
+      result = self.class.find(connection.hget(has_one_relation_key(relation_name), key))
+      has_one_references[relation_name] = result
+    end
+  end
+  
+  def has_one_relation_key(name)
+    File.join("references", has_one_relations[name][:relation].to_s)
+  end
+  
+  def save_has_one_references
+    has_one_references.each do |relation_name, reference|
+      if reference
+        connection.hset(has_one_relation_key(relation_name), key, reference.key)
+        connection.hset(has_one_relation_key(relation_name), reference.key, key)
+      end
+    end
+  end
+  
+  def self.included(base)
+    base.class_eval do
+      add_relation :has_one
+      
+      class << self
+        def has_one(relation_name, options = {})
+          has_one_relations[relation_name] = options.reverse_merge({ :relation => relation_name })
+          
+          define_method relation_name do
+            get_has_one_reference(relation_name)
+          end
+          
+          define_method "#{relation_name}=" do |a|
+            set_has_one_reference(relation_name, a)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis/validations.rb

@@ -0,0 +1,9 @@
+module Redis::Validations
+  autoload :Uniqueness, "redis/validations/uniqueness"
+
+  def self.included(base)
+    base.class_eval do
+      include Redis::Validations::Uniqueness
+    end
+  end
+end

data/lib/redis/validations/uniqueness.rb

@@ -0,0 +1,41 @@
+module Redis::Validations::Uniqueness
+  def uniqueness_key(attribute_name)
+    File.join(model_name, attribute_name.to_s.pluralize)
+  end
+
+  def self.included(base)
+    base.class_eval do
+      class_inheritable_array :unique_fields
+      self.unique_fields ||= []
+      
+      class << self
+        def validates_uniqueness_of(field)
+          unique_fields << field
+        end
+      end
+      
+      validate do |record|
+        record.unique_fields.each do |name|
+          if key_in_use = connection.hget(record.uniqueness_key(name), record.send(name))
+            if key_in_use != record.key
+              record.errors.add(name, "must be unique")
+            end
+          end
+        end
+      end
+      
+      within_save_block do |record|
+        record.unique_fields.each do |name|
+          connection.hdel(record.uniqueness_key(name), record.previous_attributes[name])
+          connection.hset(record.uniqueness_key(name), record.send(name), record.key)
+        end
+      end
+      
+      within_destroy_block do |record|
+        record.unique_fields.each do |name|
+          connection.hdel(record.uniqueness_key(name), record.send(name))
+        end
+      end
+    end
+  end
+end

data/redis-orm.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "redis/orm/version"
+
+Gem::Specification.new do |s|
+  s.name        = "redis-orm"
+  s.version     = Redis::ORM::VERSION
+  s.authors     = ["Colin MacKenzie IV"]
+  s.email       = ["sinisterchipmunk@gmail.com"]
+  s.homepage    = "http://github.com/sinisterchipmunk/redis-orm"
+  s.summary     = %q{Object-relational mapping for Redis}
+  s.description = %q{The goal of this project is to provide ORM for Redis that feels very similar to ActiveRecord.}
+
+  s.rubyforge_project = "redis-orm"
+
+  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.add_development_dependency 'rspec',      '~> 2.6.0'
+
+  s.add_runtime_dependency 'redis',          '~> 2.2.2'
+  s.add_runtime_dependency 'activemodel',    '~> 3.0.10'
+end

data/spec/redis/actions/creating_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Redis::Actions::Creating do
+  include RedisHelper
+
+  orm_class { attribute :number }
+  
+  it "should fire callbacks" do
+    before, after = 0, 0
+    orm_class { before_create { before += 1 }; after_create { after += 1 } }
+    
+    orm_class.create!
+    before.should == 1
+    after.should == 1
+  end
+  
+  it "should create and return the record" do
+    record = orm_class.create(:number => 1)
+    record.should be_kind_of(orm_class)
+    
+    record.should_not be_new_record
+    record.should_not be_changed
+  end
+
+  it "should create! and return the record" do
+    record = orm_class.create!(:number => 1)
+    record.should be_kind_of(orm_class)
+    
+    record.should_not be_new_record
+    record.should_not be_changed
+  end
+end

data/spec/redis/actions/destroying_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Redis::Actions::Destroying do
+  include RedisHelper
+
+  context "with several pre-existing records" do
+    orm_class { attribute :random }
+    
+    before(:each) do
+      10.times { |i| orm_class.new(:random => i).save! }
+    end
+    
+    it "should destroy all of them" do
+      orm_class.destroy_all
+      orm_class.all.length.should == 0
+    end
+    
+    it "should fire destroy callbacks for all of them" do
+      before, after = 0, 0
+      orm_class { before_destroy { before += 1 }; after_destroy { after += 1 } }
+      orm_class.destroy_all
+      
+      before.should == 10
+      after.should == 10
+    end
+  end
+end