simply_couch 0.1.0

data/lib/simply_couch/model/find_by.rb

@@ -0,0 +1,202 @@
+module SimplyCouch
+  module Model
+    module FindBy
+      include PaginationOptions
+      def _define_find_by(name, *args)
+        raise_when_not_found = name.to_s.end_with?('!')
+        name = name.to_s.chop.to_sym if raise_when_not_found
+        keys = name.to_s.sub(/^find_by_/, "").split("_and_").map(&:to_sym)
+
+        # replace asociation assignments with their property values if possible
+        keys.each.with_index do |key, i|
+          if properties.find{|p| p.name.to_sym == key.to_sym}.is_a?(SimplyCouch::Model::BelongsTo::Property)
+            keys[i] = "#{keys[i]}_id"
+          end
+        end
+
+        view_name = name.to_s.sub(/^find_/, "").to_sym
+        view_keys = keys.length == 1 ? keys.first : keys
+        without_deleted_view_name = "#{view_name}_withoutdeleted"
+        without_deleted_view_keys = keys + [:deleted_at]
+
+
+        unless respond_to?(view_name)
+          puts "Warning: Defining view #{self.name}##{view_name} with keys #{view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[1]})"
+          view(view_name, key: view_keys)
+        end
+
+        if !respond_to?(without_deleted_view_name) && soft_deleting_enabled?
+          puts "Warning: Defining view #{self.name}##{without_deleted_view_name} with keys #{without_deleted_view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[1]})"
+          view(without_deleted_view_name, key: without_deleted_view_keys)
+        end
+        if raise_when_not_found
+          (class << self; self end).instance_eval do
+            define_method(:"#{name}!") do |*key_args|
+              options = key_args.last.is_a?(Hash) ? key_args.pop : {}
+              options.assert_valid_keys(:with_deleted)
+              with_deleted = options.delete(:with_deleted)
+
+              raise ArgumentError, "Too many or too few arguments, require #{keys.inspect}" unless keys.size == key_args.size
+
+              key_args.map!{|a| a.is_a?(SimplyCouch::Model) ? a.id : a}
+
+              if soft_deleting_enabled? && !with_deleted
+                key_args = key_args + [nil] # deleted_at
+                result = database.view(send(without_deleted_view_name, key: (key_args.size == 1 ? key_args.first : key_args), limit: 1, include_docs: true)).first
+              else
+                result = database.view(send(view_name, key: (key_args.size == 1 ? key_args.first : key_args), limit: 1, include_docs: true)).first
+              end
+              raise SimplyCouch::RecordNotFound unless result
+              result
+            end
+          end
+          send(:"#{name}!", *args)
+        else
+          (class << self; self end).instance_eval do
+            define_method(name) do |*key_args|
+              options = key_args.last.is_a?(Hash) ? key_args.pop : {}
+              options.assert_valid_keys(:with_deleted)
+              with_deleted = options.delete(:with_deleted)
+
+              raise ArgumentError, "Too many or too few arguments, require #{keys.inspect}" unless keys.size == key_args.size
+
+              key_args.map!{|a| a.is_a?(SimplyCouch::Model) ? a.id : a}
+
+              if soft_deleting_enabled? && !with_deleted
+                key_args = key_args + [nil] # deleted_at
+                database.view(send(without_deleted_view_name, key: (key_args.size == 1 ? key_args.first : key_args), limit: 1, include_docs: true)).first
+              else
+                database.view(send(view_name, key: (key_args.size == 1 ? key_args.first : key_args), limit: 1, include_docs: true)).first
+              end
+            end
+          end
+          send(name, *args)
+        end
+      end
+
+      def _define_find_all_by(name, *args)
+        raise_when_not_found = name.to_s.end_with?('!')
+        name = name.to_s.chop.to_sym if raise_when_not_found
+        keys = name.to_s.sub(/^find_all_by_/, "").split("_and_")
+
+        # replace asociation assignments with their property values if possible
+        keys.each.with_index do |key, i|
+          if properties.find{|p| p.name.to_sym == key.to_sym}.is_a?(SimplyCouch::Model::BelongsTo::Property)
+            keys[i] = "#{keys[i]}_id"
+          end
+        end
+
+        view_name = name.to_s.sub(/^find_all_/, "").to_sym
+        count_name = name.to_s.sub(/^find_all_/, 'count_').to_sym
+        view_keys = keys.length == 1 ? keys.first : keys
+        without_deleted_view_name = "#{view_name}_withoutdeleted"
+        without_deleted_view_keys = keys + [:deleted_at]
+
+        unless respond_to?(view_name)
+          puts "Warning: Defining view #{self.name}##{view_name} with keys #{view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[1]})"
+          view(view_name, key: view_keys)
+        end
+
+        if !respond_to?(without_deleted_view_name) && soft_deleting_enabled?
+          puts "Warning: Defining view #{self.name}##{without_deleted_view_name} with keys #{without_deleted_view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[1]})"
+          view(without_deleted_view_name, key: without_deleted_view_keys)
+        end
+
+        if raise_when_not_found
+          (class << self; self end).instance_eval do
+            define_method(:"#{name}!") do |*key_args|
+              options = key_args.last.is_a?(Hash) ? key_args.pop : {}
+              with_pagination_options(options.update(total_entries: send(count_name, *key_args))) do |options|
+                options.assert_valid_keys(:with_deleted, :limit, :skip, :keys)
+                with_deleted = options.delete(:with_deleted)
+
+                key_args.map!{|a| a.is_a?(SimplyCouch::Model) ? a.id : a}
+                options[:key] = key_args.first if key_args.size == 1
+                options[:key] = key_args if key_args.size > 1
+                options[:include_docs] = true
+
+                raise ArgumentError, "Too many or too few arguments, require #{keys.inspect}" unless keys.size == key_args.size || options[:keys]
+
+                key_args.map!{|a| a.is_a?(SimplyCouch::Model) ? a.id : a}
+
+                if soft_deleting_enabled? && !with_deleted
+                  options[:key] = Array.wrap(options[:key]) + [nil] # deleted_at
+                  result = database.view(send(without_deleted_view_name, options))
+                else
+                  result = database.view(send(view_name, options))
+                end
+                raise SimplyCouch::RecordNotFound unless result && result.any?
+                result
+              end
+            end
+          end
+          send(:"#{name}!", *args)
+        else
+          (class << self; self end).instance_eval do
+            define_method(name) do |*key_args|
+              options = key_args.last.is_a?(Hash) ? key_args.pop : {}
+              with_pagination_options(options.update(total_entries: send(count_name, *key_args))) do |options|
+                options.assert_valid_keys(:with_deleted, :limit, :skip, :keys)
+                with_deleted = options.delete(:with_deleted)
+
+                key_args.map!{|a| a.is_a?(SimplyCouch::Model) ? a.id : a}
+                options[:key] = key_args.first if key_args.size == 1
+                options[:key] = key_args if key_args.size > 1
+                options[:include_docs] = true
+
+                raise ArgumentError, "Too many or too few arguments, require #{keys.inspect}" unless keys.size == key_args.size || options[:keys]
+
+                if soft_deleting_enabled? && !with_deleted
+                  options[:key] = Array.wrap(options[:key]) + [nil] # deleted_at
+                  database.view(send(without_deleted_view_name, options))
+                else
+                  database.view(send(view_name, options))
+                end
+              end
+            end
+          end
+          send(name, *args)
+        end
+      end
+
+      def _define_count_by(name, *args)
+        keys = name.to_s.sub(/^count_by_/, "").split("_and_")
+        view_name = name.to_s.sub(/^count_/, "").to_sym
+        view_keys = keys.length == 1 ? keys.first : keys
+        without_deleted_view_name = "#{view_name}_withoutdeleted"
+        without_deleted_view_keys = keys + [:deleted_at]
+
+        unless respond_to?(view_name)
+          puts "Warning: Defining view #{self.name}##{view_name} with keys #{view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[1]})"
+          view(view_name, key: view_keys)
+        end
+
+        if !respond_to?(without_deleted_view_name) && soft_deleting_enabled?
+          puts "Warning: Defining view #{self.name}##{without_deleted_view_name} with keys #{without_deleted_view_keys.inspect} at call time, please add it to the class body. (Called from #{caller[1]})"
+          view(without_deleted_view_name, key: without_deleted_view_keys)
+        end
+
+        (class << self; self end).instance_eval do
+          define_method("#{name}") do |*key_args|
+            options = key_args.last.is_a?(Hash) ? key_args.pop : {}
+            options.assert_valid_keys(:with_deleted, :keys)
+            with_deleted = options.delete(:with_deleted)
+            options[:key] = key_args.first if key_args.size == 1
+            options[:key] = key_args if key_args.size > 1
+            options[:reduce] = true
+
+            if soft_deleting_enabled? && !with_deleted
+              options[:key] = Array.wrap(options[:key]) + [nil] # deleted_at
+              database.view(send(without_deleted_view_name, options))
+            else
+              database.view(send(view_name, options))
+            end
+
+          end
+        end
+
+        send(name, *args)
+      end
+    end
+  end
+end

data/lib/simply_couch/model/finders.rb

@@ -0,0 +1,77 @@
+module SimplyCouch
+  module Model
+    module Finders
+      include PaginationOptions
+      def find(*args)
+        what = args.shift
+        options = args.last.is_a?(Hash) ? args.last : {}
+        if options && order = options.delete(:order)
+          options[:descending] = true if order == :desc
+        end
+
+        with_deleted = options.delete(:with_deleted)
+
+        result = case what
+        when :all
+          if options.has_key?(:page)
+            options[:total_entries] = count
+          end
+          if with_deleted || !soft_deleting_enabled?
+            with_pagination_options(options) do |options|
+              database.view(all_documents(options))
+            end
+          else
+            with_pagination_options(options) do |options|
+              database.view(all_documents_without_deleted(options.update(include_docs: true)))
+            end
+          end
+        when :first
+          if with_deleted || !soft_deleting_enabled?
+            database.view(all_documents(options.update(limit: 1, include_docs: true))).first
+          else
+            database.view(all_documents_without_deleted(options.update(limit: 1, include_docs: true))).first
+          end
+        else
+          raise SimplyCouch::Error, "Can't load record without an id" if what.nil?
+          document = database.load_document(what)
+          if what.is_a?(Array) # Support for multiple find
+            #TODO: extended validation and checking, for array arguments
+            raise SimplyCouch::NotImplementedError
+          else
+            # TODO, this part should be better.
+            raise(SimplyCouch::RecordNotFound, "#{self.name} could not be found with #{what.inspect}") unless document.present?
+            raise(SimplyCouch::RecordNotFound, "#{self.name} could not be found with #{what.inspect} — got #{document.class.name}") unless document.is_a?(self)
+            if document.deleted? && !with_deleted
+              raise(SimplyCouch::RecordNotFound, "#{self.name} could not be found with #{what.inspect}")
+            end
+          end
+          document
+        end
+      end
+
+      def all(*args)
+        find(:all, *args)
+      end
+
+      def first(*args)
+        find(:first, *args)
+      end
+
+      def last(*args)
+        options = args.last.is_a?(Hash) ? args.last : {}
+        find(:first, options.update(order: :desc))
+      end
+
+      def count(options = {})
+        options.assert_valid_keys(:with_deleted)
+        with_deleted = options[:with_deleted]
+
+        if with_deleted || !soft_deleting_enabled?
+          database.view(all_documents(reduce: true))
+        else
+          database.view(all_documents_without_deleted(reduce: true))
+        end
+      end
+    end
+  end
+end

data/lib/simply_couch/model/has_and_belongs_to_many.rb

@@ -0,0 +1,223 @@
+module SimplyCouch
+  module Model
+    module HasAndBelongsToMany
+      def has_and_belongs_to_many(name, options = {})
+        check_existing_properties(name, SimplyCouch::Model::HasAndBelongsToMany::Property)
+        properties << SimplyCouch::Model::HasAndBelongsToMany::Property.new(self, name, options)
+      end
+
+      def define_has_and_belongs_to_many_property(foreign_key)
+        property foreign_key
+
+        # Only allow non nil or empty values to be set
+        define_method "#{foreign_key}=" do |value|
+          super(value.is_a?(Array) ? value.select{|v| v.present?} : value)
+        end
+      end
+
+      def define_has_and_belongs_to_many_views(name, options)
+        key_order = options[:class_storing_keys] == self.name ? "doc.#{options[:foreign_key]}[index], doc._id" : "doc._id, doc.#{options[:foreign_key]}[index]"
+        value = options[:class_storing_keys] == self.name ? 1 : "{ _id :doc.#{options[:foreign_key]}[index]}"
+        association_property = if name.to_s.index('__')
+                                 # Already defined properly
+                                 name
+                               elsif options[:class_name].present?
+                                 # Determine namespace and replace last argument with given name
+                                 name_hierarchy = options[:class_name].to_s.underscore.split(/\/|::/)
+                                 name_hierarchy[-1] = name
+                                 name_hierarchy.join('__')
+                               elsif rindex = foreign_property.to_s.rindex('__')
+                                 # Make name based on current namespace
+                                 "#{foreign_property[0...rindex]}__#{name}"
+                               else
+                                 # Just return the good old name
+                                 name
+                               end
+
+        map_definition_without_deleted = <<-eos
+          function(doc) {
+            if (doc['ruby_class'] == '#{options[:class_storing_keys]}' && doc['#{options[:foreign_key]}'] != null) {
+              if (doc['#{soft_delete_attribute}'] && doc['#{soft_delete_attribute}'] != null){
+                // "soft" deleted
+              }else{
+                for (var index in doc.#{options[:foreign_key]}) {
+                  emit([#{key_order}], #{value});
+                }
+              }
+            }
+          }
+        eos
+
+        reduce_definition = options[:class_storing_keys] == self.name ? "_sum" : <<-eos
+          function(key, values) {
+            var sum = 0;
+            for (var i in values){
+              if (typeof(i) == 'number'){
+                sum = sum + i;
+              } else {
+                sum = sum + 1;
+              }
+            }
+            return sum;
+          }
+        eos
+
+        view "association_#{foreign_property}_has_and_belongs_to_many_#{association_property}",
+          :map_function => map_definition_without_deleted,
+          :reduce_function => reduce_definition,
+          :type => :custom,
+          :include_docs => true
+
+        map_definition_with_deleted = <<-eos
+          function(doc) {
+            if (doc['ruby_class'] == '#{options[:class_storing_keys]}' && doc['#{options[:foreign_key]}'] != null) {
+              for (var index in doc.#{options[:foreign_key]}) {
+                emit([#{key_order}], #{value});
+              }
+            }
+          }
+        eos
+
+        view "association_#{self.name.underscore.gsub('/', '__')}_has_and_belongs_to_many_#{name}_with_deleted",
+          :map_function => map_definition_with_deleted,
+          :reduce_function => reduce_definition,
+          :type => :custom,
+          :include_docs => true
+      end
+
+      def define_has_and_belongs_to_many_getter(name, options)
+        define_method(name) do |*args|
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          forced_reload, with_deleted, limit, descending, skip = extract_association_options(local_options)
+
+          cached_results = send("_get_cached_#{name}")
+          cache_key = _cache_key_for(local_options)
+          return cached_results[cache_key] || [] unless persisted?
+          if forced_reload || cached_results[cache_key].nil?
+            cached_results[cache_key] = find_associated_via_join_view(options[:class_name], self.class, :with_deleted => with_deleted, :limit => limit, :descending => descending, :foreign_key => options[:foreign_key], :skip => skip)
+            instance_variable_set("@#{name}", cached_results)
+          end
+          cached_results[cache_key]
+        end
+      end
+
+      def define_has_and_belongs_to_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)
+
+          if options[:class_storing_keys] == self.class.name
+            self.send("#{options[:foreign_key]}=", ((send(options[:foreign_key]) || []) + [value.id]).uniq )
+            self.save(false)
+          else
+            value.send("#{options[:foreign_key]}=", ((value.send(options[:foreign_key]) || []) + [self.id]).uniq )
+            value.save(false)
+          end
+
+          cached_results = send("_get_cached_#{name}")[:all]
+          send("_set_cached_#{name}", (cached_results || []) << value, :all)
+          nil
+        end
+      end
+
+      def define_has_and_belongs_to_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)
+
+          if options[:class_storing_keys] == self.class.name
+            raise ArgumentError, "cannot remove not mine" unless (send(options[:foreign_key]) || []).include?(value.id)
+          else
+            raise ArgumentError, "cannot remove not mine" unless (value.send(options[:foreign_key]) || []).include?(id)
+          end
+      
+          if options[:class_storing_keys] == self.class.name
+            foreign_keys = (send(options[:foreign_key]) || []) - [value.id]
+            send("#{options[:foreign_key]}=", foreign_keys)
+            save(false)
+          else
+            foreign_keys = (value.send(options[:foreign_key]) || []) - [self.id]
+            value.send("#{options[:foreign_key]}=", foreign_keys)
+            value.save(false)
+          end
+      
+          cached_results = send("_get_cached_#{name}")[:all]
+          send("_set_cached_#{name}", (cached_results || []).delete_if{|item| item.id == value.id}, :all)
+          nil
+        end
+      end
+      
+      def define_has_and_belongs_to_many_setter_remove_all(name, options)
+        define_method "remove_all_#{name}" do
+          all = send("#{name}", :force_reload => true)
+      
+          all.collect{|i| i}.each do |item|
+            send("remove_#{name.to_s.singularize}", item)
+          end
+        end
+      end
+      
+      def define_has_and_belongs_to_many_count(name, options, through = nil)
+        method_name = name.to_s.singularize.underscore.gsub('/', '__') + "_count"
+        define_method(method_name) do |*args|
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          forced_reload, with_deleted, limit, descending = extract_association_options(local_options)
+
+          if forced_reload || instance_variable_get("@#{method_name}").nil?
+            instance_variable_set("@#{method_name}", count_associated_via_join_view(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_has_and_belongs_to_many_after_destroy_cleanup(name, options)
+        if options[:class_storing_keys] == self.name
+          define_method "has_and_belongs_to_many_clean_up_after_destroy" do |property|
+            nil # deleting is enough as we store the keys
+          end
+        else
+          define_method "has_and_belongs_to_many_clean_up_after_destroy" do |property|
+            send("remove_all_#{property.name}")
+          end
+        end
+      end
+
+      class Property < SimplyCouch::Model::AssociationProperty
+
+        def initialize(owner_clazz, name, options = {})
+          options = {
+            :storing_keys => false,
+            :class_name => owner_clazz.find_association_class_name(name),
+            :foreign_key => nil,
+          }.update(options)
+
+          # there is only one pair of foreign_keys and it usualy the name of the class not storing the keys
+          if options[:foreign_key].blank?
+            if options[:storing_keys]
+              options[:foreign_key] = options[:class_name].singularize.underscore.sub(/.*\//, '').foreign_key.pluralize.to_sym
+            else
+              options[:foreign_key] = owner_clazz.name.singularize.underscore.sub(/.*\//, '').foreign_key.pluralize.to_sym
+            end
+          end
+          options[:class_storing_keys] = options[:storing_keys] ? owner_clazz.name : options[:class_name]
+          @name, @options = name, options
+
+          options.assert_valid_keys(:class_name, :foreign_key, :storing_keys, :class_storing_keys)
+
+          owner_clazz.class_eval do
+            _define_cache_accessors(name, options)
+            define_has_and_belongs_to_many_property(options[:foreign_key]) if options[:storing_keys]
+            define_has_and_belongs_to_many_views(name, options)
+            define_has_and_belongs_to_many_getter(name, options)
+            define_has_and_belongs_to_many_setter_add(name, options)
+            define_has_and_belongs_to_many_setter_remove(name, options)
+            define_has_and_belongs_to_many_setter_remove_all(name, options)
+            define_has_and_belongs_to_many_count(name, options)
+            define_has_and_belongs_to_many_after_destroy_cleanup(name, options)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/simply_couch/model/has_many.rb

@@ -0,0 +1,177 @@
+module SimplyCouch
+  module Model
+    module HasMany
+      def has_many(name, options = {})
+        check_existing_properties(name, SimplyCouch::Model::HasMany::Property)
+        properties << SimplyCouch::Model::HasMany::Property.new(self, name, options)
+      end
+
+      def define_has_many_getter(name, options)
+        define_method(name) do |*args|
+          local_options = args.first && args.first.is_a?(Hash) && args.first
+          forced_reload, with_deleted, limit, descending = extract_association_options(local_options)
+
+          cached_results = send("_get_cached_#{name}")
+          cache_key = _cache_key_for(local_options)
+          if forced_reload || cached_results[cache_key].nil? 
+            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)
+            self.class.set_parent_has_many_association_object(self, cached_results[cache_key])
+          end
+          cached_results[cache_key]
+        end
+      end
+      
+      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|
+          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
+            limit = nil
+          end
+          
+          cached_results = send("_get_cached_#{name}")
+          cache_key = _cache_key_for(local_options)
+          
+          if forced_reload || cached_results[cache_key].nil?
+            
+            # there is probably a faster way to query this
+            through_property = self.class.properties.find{|p| p.name == through}
+            if through_property && through_property.respond_to?(:options) && through_property.options[:class_name].present?
+              through_finder = through_property.options[:class_name].constantize.foreign_property
+            else
+              through_finder = through # try with the association name
+            end
+            intermediate_objects = find_associated(through_finder, 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.gsub('/', '__'), :with_deleted => with_deleted)
+            end.flatten.uniq
+            cached_results[cache_key] = through_objects
+            instance_variable_set("@#{name}", cached_results)
+          end
+          cached_results[cache_key]
+        end
+      end
+      
+      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)
+          foreign_key = "#{self.class.foreign_key}="
+          # If foreign key is namespace: admin__user, try jus user if admin_user_id is not present
+          foreign_key.gsub!(/.*__/, '') if !value.respond_to?(foreign_key) && value.respond_to?(foreign_key.sub(/.*__/, ''))
+          value.send(foreign_key, id)
+          value.save(false)
+          
+          cached_results = send("_get_cached_#{name}")[:all]
+          send("_set_cached_#{name}", (cached_results || []) << value, :all)
+          nil
+        end
+      end
+
+      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 options[:dependent] == :destroy
+            value.destroy
+          elsif options[:dependent] == :ignore
+            # skip
+          else # nullify
+            foreign_key = "#{self.class.foreign_key}="
+            # If foreign key is namespace: admin__user, try jus user if admin_user_id is not present
+            foreign_key.gsub!(/.*__/, '') if !value.respond_to?(foreign_key) && value.respond_to?(foreign_key.sub(/.*__/, ''))
+            value.send(foreign_key, nil)
+            value.save(false)
+          end
+          
+          cached_results = send("_get_cached_#{name}")[:all]
+          send("_set_cached_#{name}", (cached_results || []).delete_if{|item| item.id == value.id}, :all)
+          nil
+        end
+      end
+      
+      def define_has_many_setter_remove_all(name, options)
+        define_method "remove_all_#{name}" do
+          all = send("#{name}", :force_reload => true)
+          
+          all.collect{|i| i}.each do |item|
+            send("remove_#{name.to_s.singularize}", item)
+          end
+        end
+      end
+      
+      def define_has_many_count(name, options, through = nil)
+        method_name = name.to_s.singularize.underscore.gsub('/', '__') + "_count"
+        define_method(method_name) do |*args|
+          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 || options[:class_name], self.class, :with_deleted => with_deleted, :foreign_key => options[:foreign_key]))
+          end
+          instance_variable_get("@#{method_name}")
+        end
+      end
+      
+      def set_parent_has_many_association_object(parent, child_collection)
+        child_collection.each do |child|
+          if child.respond_to?("#{parent.class.name.to_s.singularize.downcase}=")
+            child.send("#{parent.class.name.to_s.singularize.camelize.downcase}=", parent)
+          end
+        end
+      end
+      
+      class Property < SimplyCouch::Model::AssociationProperty
+        
+        def initialize(owner_clazz, name, options = {})
+          options = {
+            :dependent => :nullify,
+            :through => nil,
+            :class_name => owner_clazz.find_association_class_name(name),
+            :foreign_key => nil
+          }.update(options)
+          @name, @options = name, options
+          
+          options.assert_valid_keys(:dependent, :through, :class_name, :foreign_key)
+          
+          if options[:through]
+            owner_clazz.class_eval do
+              _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, 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
+        
+      end
+    end
+  end
+end