simply_stored 0.3.3 → 0.3.4

data/CHANGELOG.md

@@ -1,6 +1,8 @@
 Changelog
 =============
 
+- Add support for associations not named after the class [akm]
+
 0.3.3
 
 - Fix association counting bug

data/README.md

@@ -136,6 +136,19 @@ The supported associations are: belongs_to, has_one, has_many, and has_many :thr
     post.user_count
     # => 2
     
+    
+CouchDB - Custom Associations
+
+    class Document
+      include SimplyStored::Couch
+
+      belongs_to :creator, :class_name => "User"
+      belongs_to :updater, :class_name => "User"
+    end
+    
+    d = Document.new
+    d.creator = User.first
+        
 
 CouchDB - Validations
 =============

data/lib/simply_stored/class_methods_base.rb

@@ -2,7 +2,7 @@ module SimplyStored
   module ClassMethods
     module Base
       def get_class_from_name(klass_name)
-        klass_name.to_s.gsub('__','/').gsub('__','::').classify.constantize
+        klass_name.to_s.gsub('__','/').classify.constantize
       end
       
       def foreign_key
@@ -28,4 +28,4 @@ module SimplyStored
       end
     end
   end
-end
+end

data/lib/simply_stored/couch/belongs_to.rb

@@ -3,7 +3,7 @@ module SimplyStored
   module Couch
     module BelongsTo
       
-      def belongs_to(name)
+      def belongs_to(name, options = {})
         map_definition_without_deleted = <<-eos
           function(doc) { 
             if (doc['ruby_class'] == '#{self.to_s}' && doc['#{name.to_s}_id'] != null) {
@@ -43,32 +43,37 @@ module SimplyStored
           :type => "custom",
           :include_docs => true
             
-        properties << SimplyStored::Couch::BelongsTo::Property.new(self, name)
+        properties << SimplyStored::Couch::BelongsTo::Property.new(self, name, options)
       end
 
       class Property #:nodoc:
         attr_accessor :name, :options
       
         def initialize(owner_clazz, name, options = {})
-          @name, @options = name, options
-          item_class_name = self.item_class_name
+          @name = name
+          @options = {
+            :class_name => name.to_s.singularize.camelize
+          }.update(options)
+
+          @options.assert_valid_keys(:class_name)
+
           owner_clazz.class_eval do
             attr_reader "#{name}_id"
             attr_accessor "#{name}_id_was"
             property "#{name}_id"
             
             define_method name do |*args|
-              options = args.last.is_a?(Hash) ? args.last : {}
-              options.assert_valid_keys(:force_reload, :with_deleted)
-              forced_reload = options[:force_reload] || false
-              with_deleted = options[:with_deleted] || false
+              local_options = args.last.is_a?(Hash) ? args.last : {}
+              local_options.assert_valid_keys(:force_reload, :with_deleted)
+              forced_reload = local_options[:force_reload] || false
+              with_deleted = local_options[:with_deleted] || false
               
               return instance_variable_get("@#{name}") unless instance_variable_get("@#{name}").nil? or forced_reload
-              instance_variable_set("@#{name}", send("#{name}_id").present? ? Object.const_get(item_class_name).find(send("#{name}_id"), :with_deleted => with_deleted) : nil)
+              instance_variable_set("@#{name}", send("#{name}_id").present? ? Object.const_get(self.class._find_property(name).options[:class_name]).find(send("#{name}_id"), :with_deleted => with_deleted) : nil)
             end
           
             define_method "#{name}=" do |value|
-              klass = self.class.get_class_from_name(name)
+              klass = self.class.get_class_from_name(self.class._find_property(name).options[:class_name])
               raise ArgumentError, "expected #{klass} got #{value.class}" unless value.nil? || value.is_a?(klass)
 
               instance_variable_set("@#{name}", value)
@@ -107,11 +112,7 @@ module SimplyStored
           json["#{name}_id"] = object.send("#{name}_id") if object.send("#{name}_id")
         end
         alias :value :serialize
-      
-        def item_class_name
-          @name.to_s.camelize
-        end
-      
+            
         def association?
           true
         end

data/lib/simply_stored/couch/has_many.rb

@@ -5,15 +5,15 @@ module SimplyStored
         properties << SimplyStored::Couch::HasMany::Property.new(self, name, options)
       end
 
-      def define_has_many_getter(name)
+      def define_has_many_getter(name, options)
         define_method(name) do |*args|
-          options = args.first && args.first.is_a?(Hash) && args.first
-          if options
-            options.assert_valid_keys(:force_reload, :with_deleted, :limit, :order)
-            forced_reload = options.delete(:force_reload)
-            with_deleted = options[:with_deleted]
-            limit = options[:limit]
-            descending = (options[:order] == :desc) ? true : false
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          if local_options
+            local_options.assert_valid_keys(:force_reload, :with_deleted, :limit, :order)
+            forced_reload = local_options.delete(:force_reload)
+            with_deleted = local_options[:with_deleted]
+            limit = local_options[:limit]
+            descending = (local_options[:order] == :desc) ? true : false
           else
             forced_reload = false
             with_deleted = false
@@ -22,25 +22,25 @@ module SimplyStored
           end
 
           cached_results = cached_results = send("_get_cached_#{name}")
-          cache_key = _cache_key_for(options)
+          cache_key = _cache_key_for(local_options)
           if forced_reload || cached_results[cache_key].nil? 
-            cached_results[cache_key] = find_associated(name, self.class, :with_deleted => with_deleted, :limit => limit, :descending => descending)
+            cached_results[cache_key] = find_associated(options[:class_name], self.class, :with_deleted => with_deleted, :limit => limit, :descending => descending, :foreign_key => options[:foreign_key])
             instance_variable_set("@#{name}", cached_results)
           end
           cached_results[cache_key]
         end
       end
       
-      def define_has_many_through_getter(name, through)
+      def define_has_many_through_getter(name, options, through)
         raise ArgumentError, "no such relation: #{self} - #{through}" unless instance_methods.map(&:to_sym).include?(through.to_sym)
         
         define_method(name) do |*args|
-          options = args.first && args.first.is_a?(Hash) && args.first
-          if options
-            options.assert_valid_keys(:force_reload, :with_deleted, :limit)
-            forced_reload = options[:force_reload]
-            with_deleted = options[:with_deleted]
-            limit = options[:limit]
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          if local_options
+            local_options.assert_valid_keys(:force_reload, :with_deleted, :limit)
+            forced_reload = local_options[:force_reload]
+            with_deleted = local_options[:with_deleted]
+            limit = local_options[:limit]
           else
             forced_reload = false
             with_deleted = false
@@ -48,12 +48,12 @@ module SimplyStored
           end
           
           cached_results = send("_get_cached_#{name}")
-          cache_key = _cache_key_for(options)
+          cache_key = _cache_key_for(local_options)
           
           if forced_reload || cached_results[cache_key].nil?
             
             # there is probably a faster way to query this
-            intermediate_objects = find_associated(through, self.class, :with_deleted => with_deleted, :limit => limit)
+            intermediate_objects = find_associated(through, self.class, :with_deleted => with_deleted, :limit => limit, :foreign_key => options[:foreign_key])
             
             through_objects = intermediate_objects.map do |intermediate_object|
               intermediate_object.send(name.to_s.singularize.underscore, :with_deleted => with_deleted)
@@ -65,7 +65,7 @@ module SimplyStored
         end
       end
       
-      def define_has_many_setter_add(name)
+      def define_has_many_setter_add(name, options)
         define_method("add_#{name.to_s.singularize}") do |value|
           klass = self.class.get_class_from_name(name)
           raise ArgumentError, "expected #{klass} got #{value.class}" unless value.is_a?(klass)
@@ -79,15 +79,15 @@ module SimplyStored
         end
       end
 
-      def define_has_many_setter_remove(name)
+      def define_has_many_setter_remove(name, options)
         define_method "remove_#{name.to_s.singularize}" do |value|
           klass = self.class.get_class_from_name(name)
           raise ArgumentError, "expected #{klass} got #{value.class}" unless value.is_a?(klass)
           raise ArgumentError, "cannot remove not mine" unless value.send(self.class.foreign_key.to_sym) == id
 
-          if self.class._find_property(name).options[:dependent] == :destroy
+          if options[:dependent] == :destroy
             value.destroy
-          elsif self.class._find_property(name).options[:dependent] == :ignore
+          elsif options[:dependent] == :ignore
             # skip
           else # nullify
             value.send("#{self.class.foreign_key}=", nil) 
@@ -100,7 +100,7 @@ module SimplyStored
         end
       end
       
-      def define_has_many_setter_remove_all(name)
+      def define_has_many_setter_remove_all(name, options)
         define_method "remove_all_#{name}" do
           all = send("#{name}", :force_reload => true)
           
@@ -110,27 +110,27 @@ module SimplyStored
         end
       end
       
-      def define_has_many_count(name, through = nil)
+      def define_has_many_count(name, options, through = nil)
         method_name = name.to_s.singularize.underscore + "_count"
         define_method(method_name) do |*args|
-          options = args.first && args.first.is_a?(Hash) && args.first
-          if options
-            options.assert_valid_keys(:force_reload, :with_deleted)
-            forced_reload = options[:force_reload]
-            with_deleted = options[:with_deleted]
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          if local_options
+            local_options.assert_valid_keys(:force_reload, :with_deleted)
+            forced_reload = local_options[:force_reload]
+            with_deleted = local_options[:with_deleted]
           else
             forced_reload = false
             with_deleted = false
           end
 
           if forced_reload || instance_variable_get("@#{method_name}").nil?
-            instance_variable_set("@#{method_name}", count_associated(through || name, self.class, :with_deleted => with_deleted))
+            instance_variable_set("@#{method_name}", count_associated(through || options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key]))
           end
           instance_variable_get("@#{method_name}")
         end
       end
       
-      def define_cache_accessors(name)
+      def define_cache_accessors(name, options)
         define_method "_get_cached_#{name}" do
           instance_variable_get("@#{name}") || {}
         end
@@ -141,8 +141,8 @@ module SimplyStored
           instance_variable_set("@#{name}", cached)
         end
         
-        define_method "_cache_key_for" do |options|
-          options.blank? ? :all : options.to_s
+        define_method "_cache_key_for" do |opt|
+          opt.blank? ? :all : opt.to_s
         end
       end
       
@@ -152,26 +152,28 @@ module SimplyStored
         def initialize(owner_clazz, name, options = {})
           options = {
             :dependent => :nullify,
-            :through => nil
+            :through => nil,
+            :class_name => name.to_s.singularize.camelize,
+            :foreign_key => owner_clazz.name.singularize.underscore.foreign_key
           }.update(options)
           @name, @options = name, options
           
-          options.assert_valid_keys(:dependent, :through)
+          options.assert_valid_keys(:dependent, :through, :class_name, :foreign_key)
           
           if options[:through]
             owner_clazz.class_eval do
-              define_cache_accessors(name)
-              define_has_many_through_getter(name, options[:through])
-              define_has_many_count(name, options[:through])
+              define_cache_accessors(name, options)
+              define_has_many_through_getter(name, options, options[:through])
+              define_has_many_count(name, options, options[:through])
             end
           else
             owner_clazz.class_eval do
-              define_cache_accessors(name)
-              define_has_many_getter(name)
-              define_has_many_setter_add(name)
-              define_has_many_setter_remove(name)
-              define_has_many_setter_remove_all(name)
-              define_has_many_count(name)
+              define_cache_accessors(name, options)
+              define_has_many_getter(name, options)
+              define_has_many_setter_add(name, options)
+              define_has_many_setter_remove(name, options)
+              define_has_many_setter_remove_all(name, options)
+              define_has_many_count(name, options)
             end
           end
         end

data/lib/simply_stored/couch/has_one.rb

@@ -5,9 +5,9 @@ module SimplyStored
         properties << SimplyStored::Couch::HasOne::Property.new(self, name, options)
       end
       
-      def define_has_one_setter(name)
+      def define_has_one_setter(name, options)
         define_method("#{name}=") do |value|
-          klass = self.class.get_class_from_name(name)
+          klass = self.class.get_class_from_name(self.class._find_property(name).options[:class_name])
           raise ArgumentError, "expected #{klass} got #{value.class}" unless value.nil? || value.is_a?(klass)
           old_value = send("#{name}", :force_reload => true)
           if value.nil?
@@ -19,7 +19,7 @@ module SimplyStored
           end
           
           if old_value
-            if self.class._find_property(name).options[:dependent] == :destroy
+            if options[:dependent] == :destroy
               old_value.destroy
             else
               old_value.send("#{self.class.foreign_property}=", nil)
@@ -30,20 +30,20 @@ module SimplyStored
         end
       end
       
-      def define_has_one_getter(name)
+      def define_has_one_getter(name, options)
         define_method(name) do |*args|
-          options = args.first && args.first.is_a?(Hash) && args.first
-          if options
-            options.assert_valid_keys(:force_reload, :with_deleted)
-            forced_reload = options[:force_reload]
-            with_deleted = options[:with_deleted]
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          if local_options
+            local_options.assert_valid_keys(:force_reload, :with_deleted)
+            forced_reload = local_options[:force_reload]
+            with_deleted = local_options[:with_deleted]
           else
             forced_reload = false
             with_deleted = false
           end
 
           if forced_reload || instance_variable_get("@#{name}").nil?
-            instance_variable_set("@#{name}", find_one_associated(name, self.class, :with_deleted => with_deleted))
+            instance_variable_set("@#{name}", find_one_associated(options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key]))
           end
           instance_variable_get("@#{name}")
         end
@@ -53,14 +53,18 @@ module SimplyStored
         attr_reader :name, :options
       
         def initialize(owner_clazz, name, options = {})
-          options = {:dependent => :nullify}.update(options)
+          options = {
+            :dependent => :nullify,
+            :class_name => name.to_s.singularize.camelize,
+            :foreign_key => owner_clazz.name.singularize.underscore.foreign_key
+          }.update(options)
           @name, @options = name, options
           
-          options.assert_valid_keys(:dependent)
+          options.assert_valid_keys(:dependent, :class_name, :foreign_key)
           
           owner_clazz.class_eval do
-            define_has_one_getter(name)
-            define_has_one_setter(name)
+            define_has_one_getter(name, options)
+            define_has_one_setter(name, options)
           end
         end
 

data/lib/simply_stored/instance_methods.rb

@@ -72,8 +72,8 @@ module SimplyStored
       retry_count = 0
       begin
         blk.call
-      rescue RestClient::Conflict => e
-        if self.class.auto_conflict_resolution_on_save && retry_count < max_retries && try_to_merge_conflict
+      rescue RestClient::Exception, RestClient::Conflict => e
+        if (e.http_code == 409 || e.is_a?(RestClient::Conflict)) && self.class.auto_conflict_resolution_on_save && retry_count < max_retries && try_to_merge_conflict
           retry_count += 1
           retry
         else
@@ -175,6 +175,7 @@ module SimplyStored
     end
     
     def find_associated(from, to, options = {})
+      foreign_key = options.delete(:foreign_key).gsub(/_id$/, '')
       view_options = {}
       view_options[:reduce] = false
       view_options[:descending] = options[:descending] if options[:descending]
@@ -189,11 +190,11 @@ module SimplyStored
       if options[:with_deleted]
         CouchPotato.database.view(
           self.class.get_class_from_name(from).send(
-            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}_with_deleted", view_options))
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{foreign_key}_with_deleted", view_options))
       else
         CouchPotato.database.view(
           self.class.get_class_from_name(from).send(
-            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}", view_options))
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{foreign_key}", view_options))
       end
     end
     

data/lib/simply_stored/simpledb/associations.rb

@@ -6,98 +6,112 @@ module SimplyStored
       end
     
       module ClassMethods
-        def belongs_to(klass_name)
-          define_belongs_to_getter(klass_name)
-          define_belongs_to_setter(klass_name)
+        def belongs_to(name, options = nil)
+          options = {
+            :class_name => self.formalize_class_name(name),
+            :foreign_key => "#{name}_id"
+          }.update(options || {})
+          define_belongs_to_getter(name, options)
+          define_belongs_to_setter(name, options)
         end
   
-        def has_one(klass_name, options = {})
+        def has_one(name, options = {})
           options = {
             :clear => :nullify, # or :destroy
-            :dependent => :nullify # or :destroy
+            :dependent => :nullify, # or :destroy
+            :class_name => self.formalize_class_name(name),
+            :foreign_key => self.foreign_key
           }.update(options)
     
-         define_has_one_getter(klass_name, options)
-         define_has_one_setter(klass_name, options)
-         define_has_one_dependent_clearing(klass_name, options)
+         define_has_one_getter(name, options)
+         define_has_one_setter(name, options)
+         define_has_one_dependent_clearing(name, options)
         end
   
-        def has_many(klass_name, options = {})
+        def has_many(name, options = {})
           options = {
             :clear => :nullify, # or :destroy
-            :dependent => :nullify # or :destroy
+            :dependent => :nullify, # or :destroy
+            :class_name => self.formalize_class_name(name.to_s.singularize),
+            :foreign_key => self.foreign_key
           }.update(options)
     
-          define_has_many_getter(klass_name, options)
-          define_has_many_setter_add(klass_name, options)
-          define_has_many_setter_remove(klass_name, options)
-          define_has_many_setter_remove_all(klass_name, options)
-          define_has_many_dependent_clearing(klass_name, options)
+          define_has_many_getter(name, options)
+          define_has_many_setter_add(name, options)
+          define_has_many_setter_remove(name, options)
+          define_has_many_setter_remove_all(name, options)
+          define_has_many_dependent_clearing(name, options)
         end
       
-        def define_belongs_to_getter(klass_name)
-          define_method klass_name.to_s do
-            klass = self.class.get_class_from_name(klass_name)
-            cached_version = instance_variable_get("@_cached_belongs_to_#{klass_name}")
-            if cached_version.nil? and self["#{klass_name}_id"].present?
-              cached_version = klass.find(self.send("#{klass_name}_id"), :auto_load => true)
-              instance_variable_set("@_cached_belongs_to_#{klass_name}", cached_version)
+        def define_belongs_to_getter(name, options)
+          foreign_key_column = options[:foreign_key]
+          define_method(name.to_s) do
+            klass = options[:class_name].constantize
+            cached_version = instance_variable_get("@_cached_belongs_to_#{name}")
+            if cached_version.nil? and self[foreign_key_column].present?
+              cached_version = klass.find(self.send(foreign_key_column), :auto_load => true)
+              instance_variable_set("@_cached_belongs_to_#{name}", cached_version)
             end
             cached_version
           end
         end
 
-        def define_belongs_to_setter(klass_name)
-          define_method "#{klass_name}=" do |val|
-            klass = self.class.get_class_from_name(klass_name)
+        def define_belongs_to_setter(name, options)
+          foreign_key_column = options[:foreign_key]
+          define_method("#{name}=") do |val|
+            klass = options[:class_name].constantize
             raise ArgumentError, "expected #{klass} got #{val.class}" unless val.is_a?(klass)
-            self.send("#{klass_name}_id=", val.id)
-            instance_variable_set("@_cached_belongs_to_#{klass_name}", val)
+            self.send("#{foreign_key_column}=", val.id)
+            instance_variable_set("@_cached_belongs_to_#{name}", val)
           end
         end
 
-        def define_has_one_getter(klass_name, options)
-          define_method klass_name.to_s do
-            klass = self.class.get_class_from_name(klass_name)
-            cached_version = instance_variable_get("@_cached_has_one_#{klass_name}")
+        def define_has_one_getter(name, options)
+          foreign_key_column = options[:foreign_key]
+          define_method(name.to_s) do
+            klass = options[:class_name].constantize
+            cached_version = instance_variable_get("@_cached_has_one_#{name}")
             if cached_version
-              return cached_version
+              cached_version
             else
-              cached_version = klass.send("find_by_#{self.class.foreign_key}".to_sym, self.id, {:auto_load => true})
-              instance_variable_set("@_cached_has_one_#{klass_name}", cached_version)
-              return cached_version
+              cached_version = klass.send("find_by_#{foreign_key_column}".to_sym, self.id, {:auto_load => true})
+              instance_variable_set("@_cached_has_one_#{name}", cached_version)
+              cached_version
             end
           end
         end
 
-        def define_has_one_setter(klass_name, options)
-          define_method "#{klass_name}=" do |val|
-            klass = self.class.get_class_from_name(klass_name)
+        def define_has_one_setter(name, options)
+          foreign_key_column = options[:foreign_key]
+          define_method("#{name}=") do |val|
+            klass = options[:class_name].constantize
             raise ArgumentError, "expected #{klass} got #{val.class}" unless val.is_a?(klass)
 
             # clear old
-            old = self.send("#{klass_name}")
-            old.send("#{self.class.foreign_key}=", nil) if old && options[:clear] == :nullify
+            old = self.send("#{name}")
+            old.send("#{foreign_key_column}=", nil) if old && options[:clear] == :nullify
             old.delete if old && options[:clear] == :destroy
 
             # store new
-            val.send("#{self.class.foreign_key}=", self.id)
-            instance_variable_set("@_cached_has_one_#{klass_name}", val)
+            val.send("#{foreign_key_column}=", self.id)
+            instance_variable_set("@_cached_has_one_#{name}", val)
           end
         end
 
-        def define_has_one_dependent_clearing(klass_name, options)
+        def define_has_one_dependent_clearing(name, options)
           # add method to list of methods to run when deleted
           @_clear_dependents_after_delete_methods ||= []
-          @_clear_dependents_after_delete_methods << "has_one_clear_#{klass_name}_after_destroy"
+          @_clear_dependents_after_delete_methods << "has_one_clear_#{name}_after_destroy"
 
           # define actual clearing/deleting
-          define_method "has_one_clear_#{klass_name}_after_destroy" do
-            klass = self.class.get_class_from_name(klass_name)
-            dependent = klass.send("find_by_#{self.class.foreign_key}".to_sym, self.id)
-            if options[:dependent] == :nullify
-              dependent.send("#{self.class.foreign_key}=", nil) if dependent
-            elsif options[:dependent] == :destroy
+          foreign_key_column = options[:foreign_key]
+          define_method("has_one_clear_#{name}_after_destroy") do
+            klass = options[:class_name].constantize
+            dependent = klass.send("find_by_#{foreign_key_column}".to_sym, self.id)
+            case options[:dependent]
+            when :nullify then
+              dependent.send("#{foreign_key_column}=", nil) if dependent
+            when :destroy then
               dependent.delete if dependent
             else
               raise ArgumentError, "unknown dependent method: #{options[:dependent].inspect}"
@@ -105,76 +119,81 @@ module SimplyStored
           end
         end
 
-        def define_has_many_getter(klass_name, options)
-          define_method klass_name.to_s do
-            klass = self.class.get_class_from_name(klass_name)
-            cached_version = instance_variable_get("@_cached_has_many_#{klass_name}")
+        def define_has_many_getter(name, options)
+          foreign_key_column = options[:foreign_key]
+          define_method(name.to_s) do
+            klass = options[:class_name].constantize
+            cached_version = instance_variable_get("@_cached_has_many_#{name}")
             if cached_version
-              return cached_version
+              cached_version
             else
-              cached_version = klass.send("find_all_by_#{self.class.foreign_key}".to_sym, self.id, {:auto_load => true})
-              instance_variable_set("@_cached_has_many_#{klass_name}", cached_version)
-              return cached_version
+              cached_version = klass.send("find_all_by_#{foreign_key_column}".to_sym, self.id, {:auto_load => true})
+              instance_variable_set("@_cached_has_many_#{name}", cached_version)
+              cached_version
             end
           end
         end
 
-        def define_has_many_setter_add(klass_name, options)
-          define_method "add_#{klass_name.to_s.singularize}" do |val|
-            klass = self.class.get_class_from_name(klass_name)
+        def define_has_many_setter_add(name, options)
+          foreign_key_column = options[:foreign_key]
+          define_method("add_#{name.to_s.singularize}") do |val|
+            klass = options[:class_name].constantize
             raise ArgumentError, "expected #{klass} got #{val.class}" unless val.is_a?(klass)
-            val.send("#{self.class.foreign_key}=", self.id)
+            val.send("#{foreign_key_column}=", self.id)
             val.save(false)
-            cached_version = instance_variable_get("@_cached_has_many_#{klass_name}") || []
-            instance_variable_set("@_cached_has_many_#{klass_name}", cached_version << val)
+            cached_version = instance_variable_get("@_cached_has_many_#{name}") || []
+            instance_variable_set("@_cached_has_many_#{name}", cached_version << val)
           end
         end
 
-        def define_has_many_setter_remove(klass_name, options)
-          define_method "remove_#{klass_name.to_s.singularize}" do |val|
-            klass = self.class.get_class_from_name(klass_name)
+        def define_has_many_setter_remove(name, options)
+          foreign_key_column = options[:foreign_key]
+          define_method("remove_#{name.to_s.singularize}") do |val|
+            klass = options[:class_name].constantize
             raise ArgumentError, "expected #{klass} got #{val.class}" unless val.is_a?(klass)
-            raise ArgumentError, "cannot remove not mine" unless val.send(self.class.foreign_key.to_sym) == self.id
-            if options[:clear] == :nullify
-              val.send("#{self.class.foreign_key}=", nil) 
+            raise ArgumentError, "cannot remove not mine" unless val.send(foreign_key_column) == self.id
+            case options[:clear]
+            when :nullify then
+              val.send("#{foreign_key_column}=", nil) 
               val.save(false)
-            elsif options[:clear] == :destroy
+            when :destroy then
               val.delete
             else
               raise "Unknown option for clear: #{option[:clear]}"
             end
-            cached_version = instance_variable_get("@_cached_has_many_#{klass_name}") || []
-            instance_variable_set("@_cached_has_many_#{klass_name}", cached_version.delete_if{|x| x.id == val.id})
+            cached_version = instance_variable_get("@_cached_has_many_#{name}") || []
+            instance_variable_set("@_cached_has_many_#{name}", cached_version.delete_if{|x| x.id == val.id})
           end
         end
 
-        def define_has_many_setter_remove_all(klass_name, options)
-          define_method "remove_all_#{klass_name}" do
-            klass = self.class.get_class_from_name(klass_name)
-
-            all = klass.send("find_all_by_#{self.class.foreign_key}".to_sym, self.id)
-
+        def define_has_many_setter_remove_all(name, options)
+          foreign_key_column = options[:foreign_key]
+          define_method("remove_all_#{name}") do
+            klass = options[:class_name].constantize
+            all = klass.send("find_all_by_#{foreign_key_column}".to_sym, self.id)
             all.each do |item|
-              self.send("remove_#{klass_name.to_s.singularize}", item)
+              self.send("remove_#{name.to_s.singularize}", item)
             end
-            instance_variable_set("@_cached_has_many_#{klass_name}", [])
+            instance_variable_set("@_cached_has_many_#{name}", [])
           end
         end
 
-        def define_has_many_dependent_clearing(klass_name, options)
+        def define_has_many_dependent_clearing(name, options)
           # add method to list of methods to run when deleted
           @_clear_dependents_after_delete_methods ||= []
-          @_clear_dependents_after_delete_methods << "has_many_clear_#{klass_name}_after_destroy"
+          @_clear_dependents_after_delete_methods << "has_many_clear_#{name}_after_destroy"
 
           # define actual clearing/deleting
-          define_method "has_many_clear_#{klass_name}_after_destroy" do
-            klass = self.class.get_class_from_name(klass_name)
-            dependents = klass.send("find_all_by_#{self.class.foreign_key}".to_sym, self.id)
-            if options[:dependent] == :nullify
+          foreign_key_column = options[:foreign_key]
+          define_method("has_many_clear_#{name}_after_destroy") do
+            klass = options[:class_name].constantize
+            dependents = klass.send("find_all_by_#{foreign_key_column}".to_sym, self.id)
+            case options[:dependent]
+            when :nullify then
               dependents.each do |dependent|
-                dependent.send("#{self.class.foreign_key}=", nil)
+                dependent.send("#{foreign_key_column}=", nil)
               end
-            elsif options[:dependent] == :destroy
+            when :destroy then
               dependents.each do |dependent|
                 dependent.delete
               end
@@ -193,4 +212,4 @@ module SimplyStored
       end
     end
   end
-end
+end

data/lib/simply_stored/simpledb.rb

@@ -206,7 +206,11 @@ module SimplyStored
     end
   
     def self.get_class_from_name(klass_name)
-      klass_name.to_s.gsub('__','/').gsub('__','::').classify.constantize
+      klass_name.to_s.gsub('__','/').classify.constantize
+    end
+  
+    def self.formalize_class_name(name)
+      name.to_s.gsub('__','/').gsub('__','::').classify
     end
   end
-end
+end

data/lib/simply_stored.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/simply_stored/storage')
 require File.expand_path(File.dirname(__FILE__) + '/simply_stored/class_methods_base')
 
 module SimplyStored
-  VERSION = '0.3.3'
+  VERSION = '0.3.4'
   class Error < RuntimeError; end
   class RecordNotFound < RuntimeError; end
 end

data/test/fixtures/couch.rb

@@ -10,6 +10,7 @@ class User
   has_many :strict_posts
   has_many :hemorrhoids
   has_many :pains, :through => :hemorrhoids
+  has_many :docs, :class_name => "Document", :foreign_key => "editor_id"
   
   view :by_name_and_created_at, :key => [:name, :created_at]
 end
@@ -44,6 +45,13 @@ class Category
   validates_inclusion_of :name, :in => ["food", "drinks", "party"], :allow_blank => true
 end
 
+class Document
+  include SimplyStored::Couch
+  
+  belongs_to :author, :class_name => "User"
+  belongs_to :editor, :class_name => "User"
+end
+
 class Tag
   include SimplyStored::Couch
   

data/test/simply_stored_couch_test.rb

@@ -474,6 +474,25 @@ class CouchTest < Test::Unit::TestCase
             assert_nil post.user
           end
         end
+        
+        context "with aliased associations" do
+          should "allow different names for the same class" do
+            editor = User.create(:name => 'Editor', :title => 'Dr.')
+            author = User.create(:name => 'author', :title => 'Dr.')
+            assert_not_nil editor.id, editor.errors.inspect
+            assert_not_nil author.id, author.errors.inspect
+            
+            doc = Document.create(:editor => editor, :author => author)
+            doc.save!
+            assert_equal editor.id, doc.editor_id
+            assert_equal author.id, doc.author_id
+            doc = Document.find(doc.id)
+            assert_not_nil doc.editor, doc.inspect
+            assert_not_nil doc.author
+            assert_equal editor.id, doc.editor.id
+            assert_equal author.id, doc.author.id
+          end
+        end
       end
       
       context "with has_many" do

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 3
-  version: 0.3.3
+  - 4
+  version: 0.3.4
 platform: ruby
 authors: 
 - Mathias Meyer, Jonathan Weiss
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-19 00:00:00 +02:00
+date: 2010-06-17 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency