redis-orm 0.0.1 → 0.0.2

data/README.md

@@ -178,6 +178,9 @@ You can use these callbacks to perform commands directly upon the Redis database
 
 ## Configuration
 
+
+### connection
+
 You can set the host and port for Redis:
 
     Redis.host = 'localhost'
@@ -187,3 +190,13 @@ If you already have an active connection, however, these changes will not take e
 
     Redis.connection = Redis.new(:host => 'localhost', :port => 3000)
 
+
+### serializer
+
+By default, Redis serializes the attributes using Marshal. If you would prefer to store data in some other format, simply replace Redis::ORM.serializer with your choice. Anything that responds to #dump and #load will work (JSON, YAML, etc):
+
+    Redis::ORM.serializer = YAML
+
+Obviously, you can use your own custom serializer just as easily. Just pass in an object that returns a string for `#dump(object)` and an object for `#load(string)` and you're good to go.
+
+It's worth noting that there can only be one serializer for all models. It's also worth noting that it's a Bad Idea to switch serializers once you've got a database full of data. If you need to switch, for instance, from JSON to YAML serialization, you'll need to come up with a migration scheme yourself.

data/lib/redis/actions/destroying.rb

@@ -13,7 +13,7 @@ module Redis::Actions::Destroying
       # run_callbacks(:before_destroy)
       run_callbacks(:destroy) do
         transaction do
-          connection.del key
+          connection.del id
           within_destroy_blocks.each do |method_name_or_block|
             if method_name_or_block.kind_of?(String) || method_name_or_block.kind_of?(Symbol)
               send method_name_or_block

data/lib/redis/actions/finding.rb

@@ -4,10 +4,10 @@ module Redis::Actions::Finding
   end
   
   module ClassMethods
-    def find(key)
-      data = connection.get(key)
+    def find(id)
+      data = connection.get(id)
       if data
-        klass_name = key.split(/\//)[0]
+        klass_name = id.split(/\//)[0]
         klass = (klass_name.camelize.constantize rescue self)
         instance = klass.new(serializer.load(data))
         instance.set_unchanged!
@@ -18,8 +18,8 @@ module Redis::Actions::Finding
     end
   
     def all
-      connection.hgetall(File.join(model_name, "keys")).collect do |key|
-        find(key.first)
+      connection.hgetall(File.join(model_name, "ids")).collect do |id|
+        find(id.first)
       end
     end
   end

data/lib/redis/actions/saving.rb

@@ -10,7 +10,7 @@ module Redis::Actions::Saving
   
   def save
     if valid?
-      define_key if key.nil?
+      define_id if id.nil?
       run_callbacks(:save) do
         transaction do
           within_save_blocks.each do |block_or_method|
@@ -20,7 +20,7 @@ module Redis::Actions::Saving
               block_or_method.call self
             end
           end
-          connection.set(key, serializer.dump(attributes))
+          connection.set(id, serializer.dump(attributes))
         end
       end
       set_unchanged!
@@ -34,8 +34,8 @@ module Redis::Actions::Saving
     raise "Record was not saved: #{errors.full_messages}" unless save
   end
   
-  def define_key
-    self.key = File.join(model_name, connection.incr("__uniq__").to_s)
+  def define_id
+    self.id = File.join(model_name, connection.incr("__uniq__").to_s)
   end
 
   module ClassMethods

data/lib/redis/orm.rb

@@ -23,19 +23,19 @@ class Redis::ORM
   include Redis::Relations
   include Redis::Validations
   
-  attribute :key
-  validates_uniqueness_of :key
+  attribute :id
+  validates_uniqueness_of :id
   
   class << self
     delegate :connection, :to => :Redis
   end
 
   def to_key
-    persisted? ? key : nil
+    persisted? ? id : nil
   end
   
   def to_param
-    persisted? ? File.join(model_name, key) : nil
+    persisted? ? File.join(model_name, id) : nil
   end
   
   def persisted?
@@ -54,6 +54,6 @@ class Redis::ORM
   end
   
   def ==(other)
-    other && key == other.key
+    other && id == other.id
   end
 end

data/lib/redis/orm/version.rb

@@ -3,7 +3,7 @@ class Redis
     module Version
       MAJOR = 0
       MINOR = 0
-      PATCH = 1
+      PATCH = 2
       PREREL = nil
     
       STRING = PREREL ? [MAJOR, MINOR, PATCH, PREREL].join('.') : [MAJOR, MINOR, PATCH].join('.')

data/lib/redis/relations/belongs_to.rb

@@ -11,21 +11,21 @@ module Redis::Relations::BelongsTo
     if belongs_to_references.key?(name)
       belongs_to_references[name]
     else
-      result = self.class.find(connection.hget(belongs_to_relation_key(name), key))
+      result = self.class.find(connection.hget(belongs_to_relation_id(name), id))
       belongs_to_references[name] = result
     end
   end
   
-  def belongs_to_relation_key(name)
+  def belongs_to_relation_id(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
+        reference = reference.id
       end
-      connection.hset(belongs_to_relation_key(relation_name), key, reference)
+      connection.hset(belongs_to_relation_id(relation_name), id, reference)
     end
   end
   

data/lib/redis/relations/has_many.rb

@@ -7,7 +7,7 @@ module Redis::Relations::HasMany
     if has_many_references.key?(relation_name)
       has_many_references[relation_name]
     else
-      result = connection.hget(has_many_relation_key(relation_name), key)
+      result = connection.hget(has_many_relation_id(relation_name), id)
       if result
         result = serializer.load(result)
         if result.respond_to?(:collect)
@@ -24,15 +24,15 @@ module Redis::Relations::HasMany
   
   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)
+      array = array.collect { |a| a.id }
+      connection.hset(has_many_relation_id(relation_name), id, serializer.dump(array))
+      array.each do |aid|
+        connection.hset(has_many_relation_id(relation_name), aid, id)
       end
     end
   end
   
-  def has_many_relation_key(name)
+  def has_many_relation_id(name)
     File.join("references", has_many_relations[name][:relation].to_s)
   end
   

data/lib/redis/relations/has_one.rb

@@ -11,20 +11,20 @@ module Redis::Relations::HasOne
     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))
+      result = self.class.find(connection.hget(has_one_relation_id(relation_name), id))
       has_one_references[relation_name] = result
     end
   end
   
-  def has_one_relation_key(name)
+  def has_one_relation_id(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)
+        connection.hset(has_one_relation_id(relation_name), id, reference.id)
+        connection.hset(has_one_relation_id(relation_name), reference.id, id)
       end
     end
   end

data/lib/redis/validations/uniqueness.rb

@@ -1,5 +1,5 @@
 module Redis::Validations::Uniqueness
-  def uniqueness_key(attribute_name)
+  def uniqueness_id(attribute_name)
     File.join(model_name, attribute_name.to_s.pluralize)
   end
 
@@ -16,8 +16,8 @@ module Redis::Validations::Uniqueness
       
       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
+          if id_in_use = connection.hget(record.uniqueness_id(name), record.send(name))
+            if id_in_use != record.id
               record.errors.add(name, "must be unique")
             end
           end
@@ -26,14 +26,14 @@ module Redis::Validations::Uniqueness
       
       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)
+          connection.hdel(record.uniqueness_id(name), record.previous_attributes[name])
+          connection.hset(record.uniqueness_id(name), record.send(name), record.id)
         end
       end
       
       within_destroy_block do |record|
         record.unique_fields.each do |name|
-          connection.hdel(record.uniqueness_key(name), record.send(name))
+          connection.hdel(record.uniqueness_id(name), record.send(name))
         end
       end
     end

data/spec/redis/actions/finding_spec.rb

@@ -17,9 +17,9 @@ describe Redis::Actions::Finding do
     end
   end
   
-  context "with key not matching known constants" do
+  context "with id not matching known constants" do
     it "should find record with its own class" do
-      orm_class.create!(:key => '1234')
+      orm_class.create!(:id => '1234')
       orm_class.find('1234').should be_kind_of(orm_class)
     end
   end

data/spec/redis/orm_spec.rb

@@ -39,16 +39,16 @@ describe Redis::ORM do
           subject.should_not be_changed
         end
       
-        it "should have a key" do
-          subject.key.should_not be_nil
+        it "should have a id" do
+          subject.id.should_not be_nil
         end
       
         it "should be find-able" do
-          orm_class.find(subject.key).should == subject
+          orm_class.find(subject.id).should == subject
         end
       
         it "should find separate instances" do
-          orm_class.find(subject.key).should_not be(subject)
+          orm_class.find(subject.id).should_not be(subject)
         end
       end
     end

data/spec/redis/relations/belongs_to_spec.rb

@@ -12,7 +12,7 @@ describe Redis::Relations::BelongsTo do
     subject.other = other
     subject.save!
     
-    orm_class.find(subject.key).other.should be_kind_of(orm_class)
+    orm_class.find(subject.id).other.should be_kind_of(orm_class)
   end
   
   it "mass assignment" do
@@ -26,29 +26,3 @@ describe Redis::Relations::BelongsTo do
     subject.save!
   end
 end
-
-
-=begin
-
-class Aye
-  has_many bees(, :foreign_key => :aye_id)
-end
-
-class Bee
-  (attribute :aye_id)
-  belongs_to aye
-end
-
-
-
-# reference built on the relation (foreign_key):
-# has_many uses its own name while belongs_to uses
-# the reference name
-
-references/ayes
-  Aye/1 => [ Bee/1, Bee/2 ]  # has_many stores an array of keys
-  Bee/1 => Aye/1             # belongs_to stores a single key
-  Bee/2 => Aye/1
-  
-
-=end

data/spec/redis/relations/has_many_spec.rb

@@ -14,9 +14,9 @@ describe Redis::Relations::HasMany do
     end
     subject.save!
     
-    orm_class.find(subject.key).others.should have(10).items
+    orm_class.find(subject.id).others.should have(10).items
     for i in 0...10
-      orm_class.find(subject.key).others[i].should be_kind_of(orm_class)
+      orm_class.find(subject.id).others[i].should be_kind_of(orm_class)
     end
   end
   

data/spec/redis/relations/has_one_spec.rb

@@ -11,7 +11,7 @@ describe Redis::Relations::HasOne do
     subject.other = other
     subject.save!
     
-    orm_class.find(subject.key).other.should be_kind_of(orm_class)
+    orm_class.find(subject.id).other.should be_kind_of(orm_class)
   end
 
   it "mass assignment" do

metadata

@@ -2,7 +2,7 @@
 name: redis-orm
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Colin MacKenzie IV