tenacity 0.3.0 → 0.4.0

data/lib/tenacity/orm_ext/couchrest.rb

@@ -1,140 +1,159 @@
 module Tenacity
-  # Tenacity relationships on CouchRest objects require no special keys
-  # defined on the object.  Tenacity will define the keys that it needs
-  # to support the relationships.  Take the following class for example:
-  #
-  #   class Car < CouchRest::ExtendedDocument
-  #     include Tenacity
-  #
-  #     t_has_many    :wheels
-  #     t_has_one     :dashboard
-  #     t_belongs_to  :driver
-  #   end
-  #
-  # == t_belongs_to
-  #
-  # The +t_belongs_to+ association will define a property named after the association.
-  # The example above will create a property named <tt>:driver_id</tt>
-  #
-  #
-  # == t_has_one
-  #
-  # The +t_has_one+ association will not define any new properties on the object, since
-  # the associated object holds the foreign key.
-  #
-  #
-  # == t_has_many
-  #
-  # The +t_has_many+ association will define a property named after the association.
-  # The example above will create a property named <tt>:wheels_ids</tt>
-  #
-  module CouchRest
-
-    def self.setup(model) #:nodoc:
-      begin
-        require 'couchrest_model'
-        if model.ancestors.include?(::CouchRest::Model::Base)
-          model.send :include, CouchRest::InstanceMethods
-          model.extend CouchRest::ClassMethods
-        end
-      rescue LoadError
-        # CouchRest::Model not available
-      end
+  module OrmExt
+    # Tenacity relationships on CouchRest objects require no special keys
+    # defined on the object.  Tenacity will define the keys that it needs
+    # to support the relationships.  Take the following class for example:
+    #
+    #   class Car < CouchRest::ExtendedDocument
+    #     include Tenacity
+    #
+    #     t_has_many    :wheels
+    #     t_has_one     :dashboard
+    #     t_belongs_to  :driver
+    #   end
+    #
+    # == t_belongs_to
+    #
+    # The +t_belongs_to+ association will define a property named after the association.
+    # The example above will create a property named <tt>:driver_id</tt>
+    #
+    #
+    # == t_has_one
+    #
+    # The +t_has_one+ association will not define any new properties on the object, since
+    # the associated object holds the foreign key.
+    #
+    #
+    # == t_has_many
+    #
+    # The +t_has_many+ association will define a property named after the association.
+    # The example above will create a property named <tt>:wheels_ids</tt>
+    #
+    module CouchRest
+
+      def self.setup(model) #:nodoc:
+        begin
+          require 'couchrest_model'
+          if model.ancestors.include?(::CouchRest::Model::Base)
+            model.send :include, CouchRest::InstanceMethods
+            model.extend CouchRest::ClassMethods
+          end
+        rescue LoadError
+          # CouchRest::Model not available
+        end
 
-      begin
-        require 'couchrest_extended_document'
-        if model.ancestors.include?(::CouchRest::ExtendedDocument)
-          model.send :include, CouchRest::InstanceMethods
-          model.extend CouchRest::ClassMethods
+        begin
+          require 'couchrest_extended_document'
+          if model.ancestors.include?(::CouchRest::ExtendedDocument)
+            model.send :include, CouchRest::InstanceMethods
+            model.extend CouchRest::ClassMethods
+          end
+        rescue LoadError
+          # CouchRest::ExtendedDocument not available
         end
-      rescue LoadError
-        # CouchRest::ExtendedDocument not available
-      end
 
-      # For pre 1.0 versions of couchrest
-      begin
-        require 'couchrest'
-        if model.ancestors.include?(::CouchRest::ExtendedDocument)
-          model.send :include, CouchRest::InstanceMethods
-          model.extend CouchRest::ClassMethods
+        # For pre 1.0 versions of couchrest
+        begin
+          require 'couchrest'
+          if model.ancestors.include?(::CouchRest::ExtendedDocument)
+            model.send :include, CouchRest::InstanceMethods
+            model.extend CouchRest::ClassMethods
+          end
+        rescue LoadError
+        rescue NameError
+          # CouchRest::ExtendedDocument not available
         end
-      rescue LoadError
-      rescue NameError
-        # CouchRest::ExtendedDocument not available
       end
-    end
 
-    module ClassMethods #:nodoc:
-      def _t_find(id)
-        (id.nil? || id.strip == "") ? nil : get(id)
-      end
+      module ClassMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
 
-      def _t_find_bulk(ids)
-        return [] if ids.nil? || ids.empty?
+        def _t_id_type
+          String
+        end
 
-        docs = []
-        result = database.get_bulk ids
-        result['rows'].each do |row|
-          docs << (row['doc'].nil? ? nil : create_from_database(row['doc']))
+        def _t_find(id)
+          (id.nil? || id.strip == "") ? nil : get(_t_serialize(id))
         end
-        docs.reject { |doc| doc.nil? }
-      end
 
-      def _t_find_first_by_associate(property, id)
-        self.send("by_#{property}", :key => id.to_s).first
-      end
+        def _t_find_bulk(ids)
+          return [] if ids.nil? || ids.empty?
+          ids = [ids] unless ids.class == Array
 
-      def _t_find_all_by_associate(property, id)
-        self.send("by_#{property}", :key => id.to_s)
-      end
+          docs = []
+          result = database.get_bulk(_t_serialize_ids(ids))
+          result['rows'].each do |row|
+            docs << (row['doc'].nil? ? nil : create_from_database(row['doc']))
+          end
+          docs.reject { |doc| doc.nil? }
+        end
 
-      def _t_initialize_has_many_association(association)
-        unless self.respond_to?(association.foreign_keys_property)
-          property association.foreign_keys_property, :type => [String]
-          view_by association.foreign_keys_property
-          after_save { |record| record.class._t_save_associates(record, association) if record.class.respond_to?(:_t_save_associates) }
+        def _t_find_first_by_associate(property, id)
+          self.send("by_#{property}", :key => _t_serialize(id)).first
         end
-      end
 
-      def _t_initialize_belongs_to_association(association)
-        property_name = association.foreign_key
-        unless self.respond_to?(property_name)
-          property property_name, :type => String
-          view_by property_name
-          before_save { |record| _t_stringify_belongs_to_value(record, association) if self.respond_to?(:_t_stringify_belongs_to_value) }
+        def _t_find_all_by_associate(property, id)
+          self.send("by_#{property}", :key => _t_serialize(id))
         end
-      end
 
-      def _t_delete(ids, run_callbacks=true)
-        docs = _t_find_bulk(ids)
-        if run_callbacks
-          docs.each { |doc| doc.destroy }
-        else
-          docs.each { |doc| database.delete_doc(doc) }
+        def _t_initialize_tenacity
+          after_save { |record| record._t_save_autosave_associations }
         end
-      end
-    end
 
-    module InstanceMethods #:nodoc:
-      def _t_reload
-        return if self.id.nil?
-        new_doc = database.get(self.id)
-        self.clear
-        new_doc.each { |k,v| self[k] = new_doc[k] }
-      end
+        def _t_initialize_has_one_association(association)
+          before_destroy { |record| record._t_cleanup_has_one_association(association) }
+        end
 
-      def _t_associate_many(association, associate_ids)
-        self.send(association.foreign_keys_property + '=', associate_ids.map { |associate_id| associate_id.to_s })
-      end
+        def _t_initialize_has_many_association(association)
+          unless self.respond_to?(association.foreign_keys_property)
+            property association.foreign_keys_property, :type => [id_class_for(association)]
+            view_by association.foreign_keys_property
+            after_save { |record| record.class._t_save_associates(record, association) if record.class.respond_to?(:_t_save_associates) }
+            after_destroy { |record| record._t_cleanup_has_many_association(association) }
+          end
+        end
+
+        def _t_initialize_belongs_to_association(association)
+          property_name = association.foreign_key
+          unless self.respond_to?(property_name)
+            property property_name, :type => id_class_for(association)
+            property association.polymorphic_type, :type => String if association.polymorphic?
+            view_by property_name
+            after_destroy { |record| record._t_cleanup_belongs_to_association(association) }
+          end
+        end
 
-      def _t_get_associate_ids(association)
-        self.send(association.foreign_keys_property) || []
+        def _t_delete(ids, run_callbacks=true)
+          docs = _t_find_bulk(ids)
+          if run_callbacks
+            docs.each { |doc| doc.destroy }
+          else
+            docs.each { |doc| database.delete_doc(doc) }
+          end
+        end
       end
 
-      def _t_clear_associates(association)
-        self.send(association.foreign_keys_property + '=', [])
+      module InstanceMethods #:nodoc:
+        def _t_reload
+          return if self.id.nil?
+          new_doc = database.get(self.id)
+          self.clear
+          new_doc.each { |k,v| self[k] = new_doc[k] }
+        end
+
+        def _t_associate_many(association, associate_ids)
+          self.send(association.foreign_keys_property + '=', associate_ids)
+        end
+
+        def _t_get_associate_ids(association)
+          self.send(association.foreign_keys_property) || []
+        end
+
+        def _t_clear_associates(association)
+          self.send(association.foreign_keys_property + '=', [])
+        end
       end
-    end
 
+    end
   end
 end

data/lib/tenacity/orm_ext/datamapper.rb

@@ -1,139 +1,165 @@
 module Tenacity
-  # Tenacity relationships on DataMapper objects require that certain columns
-  # exist on the associated table, and that join tables exist for one-to-many
-  # relationships.  Take the following class for example:
-  #
-  #   class Car
-  #     include DataMapper::Resource
-  #     include Tenacity
-  #
-  #     property :id, Serial
-  #     property :driver_id, String
-  #
-  #     t_has_many    :wheels
-  #     t_has_one     :dashboard
-  #     t_belongs_to  :driver
-  #   end
-  #
-  #
-  # == t_belongs_to
-  #
-  # The +t_belongs_to+ association requires that a property exist in the table
-  # to hold the id of the assoicated object.
-  #
-  #
-  # == t_has_one
-  #
-  # The +t_has_one+ association requires no special column in the table, since
-  # the associated object holds the foreign key.
-  #
-  #
-  # == t_has_many
-  #
-  # The +t_has_many+ association requires that a join table exist to store the
-  # associations.  The name of the join table follows ActiveRecord conventions.
-  # The name of the join table in this example would be cars_wheels, since cars
-  # comes before wheels when shorted alphabetically.
-  #
-  #   create_table :car_wheels do
-  #     column :car_id, Integer
-  #     column :wheel_id, String
-  #   end
-  #
-  module DataMapper
-
-    def self.setup(model)
-      require 'datamapper'
-      if model.included_modules.include?(::DataMapper::Resource)
-        model.send :include, DataMapper::InstanceMethods
-        model.extend DataMapper::ClassMethods
+  module OrmExt
+    # Tenacity relationships on DataMapper objects require that certain columns
+    # exist on the associated table, and that join tables exist for one-to-many
+    # relationships.  Take the following class for example:
+    #
+    #   class Car
+    #     include DataMapper::Resource
+    #     include Tenacity
+    #
+    #     property :id, Serial
+    #     property :driver_id, String
+    #
+    #     t_has_many    :wheels
+    #     t_has_one     :dashboard
+    #     t_belongs_to  :driver
+    #   end
+    #
+    #
+    # == t_belongs_to
+    #
+    # The +t_belongs_to+ association requires that a property exist in the table
+    # to hold the id of the assoicated object.
+    #
+    #
+    # == t_has_one
+    #
+    # The +t_has_one+ association requires no special column in the table, since
+    # the associated object holds the foreign key.
+    #
+    #
+    # == t_has_many
+    #
+    # The +t_has_many+ association requires that a join table exist to store the
+    # associations.  The name of the join table follows ActiveRecord conventions.
+    # The name of the join table in this example would be cars_wheels, since cars
+    # comes before wheels when shorted alphabetically.
+    #
+    #   create_table :car_wheels do
+    #     column :car_id, Integer
+    #     column :wheel_id, String
+    #   end
+    #
+    module DataMapper
+
+      def self.setup(model)
+        require 'datamapper'
+        if model.included_modules.include?(::DataMapper::Resource)
+          model.send :include, DataMapper::InstanceMethods
+          model.extend DataMapper::ClassMethods
+        end
+      rescue LoadError
+        # DataMapper not available
       end
-    rescue LoadError
-      # DataMapper not available
-    end
 
-    module ClassMethods #:nodoc:
-      def _t_find(id)
-        get(id)
-      end
+      module ClassMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
 
-      def _t_find_bulk(ids)
-        return [] if ids.nil? || ids.empty?
-        all(:id => ids)
-      end
+        def _t_id_type
+          Integer
+        end
 
-      def _t_find_first_by_associate(property, id)
-        first(property => id.to_s)
-      end
+        def _t_find(id)
+          get(_t_serialize(id))
+        end
 
-      def _t_find_all_by_associate(property, id)
-        all(property => id.to_s)
-      end
+        def _t_find_bulk(ids)
+          return [] if ids.nil? || ids == []
+          all(:id => _t_serialize_ids(ids))
+        end
 
-      def _t_initialize_has_many_association(association)
-        after :save do |record|
-          record.class._t_save_associates(record, association)
+        def _t_find_first_by_associate(property, id)
+          first(property => _t_serialize(id))
         end
-      end
 
-      def _t_initialize_belongs_to_association(association)
-        before :save do |record|
-          record.class._t_stringify_belongs_to_value(record, association)
+        def _t_find_all_by_associate(property, id)
+          all(property => _t_serialize(id))
         end
-      end
 
-      def _t_delete(ids, run_callbacks=true)
-        objects = _t_find_bulk(ids)
-        if run_callbacks
-          objects.each { |object| object.destroy }
-        else
-          objects.each { |object| object.destroy! }
+        def _t_initialize_tenacity
+          after :save do |record|
+            record._t_save_autosave_associations
+          end
         end
-      end
-    end
 
-    module InstanceMethods #:nodoc:
-      # DataMapper will not issue callbacks unless at least one of the properties is dirty.
-      # So, taint the object by marking one of the attributes as dirty, save the object,
-      # and resture the persisted_state by reloading the object from the database.
-      def save
-        if clean?
-          taint!; super; reload
-        else
-          super
+        def _t_initialize_has_one_association(association)
+          after :destroy do |record|
+            record._t_cleanup_has_one_association(association)
+          end
         end
-      end
 
-      def _t_reload
-        reload
-      end
+        def _t_initialize_has_many_association(association)
+          after :save do |record|
+            record.class._t_save_associates(record, association)
+          end
 
-      def _t_clear_associates(association)
-        self.repository.adapter.execute("delete from #{association.join_table} where #{association.association_key} = #{self.id}")
-      end
+          after :destroy do |record|
+            record._t_cleanup_has_many_association(association)
+          end
+        end
 
-      def _t_associate_many(association, associate_ids)
-        self.transaction do
-          _t_clear_associates(association)
-          associate_ids.each do |associate_id|
-            self.repository.adapter.execute("insert into #{association.join_table} (#{association.association_key}, #{association.association_foreign_key}) values (#{self.id}, '#{associate_id}')")
+        def _t_initialize_belongs_to_association(association)
+          after :destroy do |record|
+            record._t_cleanup_belongs_to_association(association)
           end
         end
-      end
 
-      def _t_get_associate_ids(association)
-        return [] if self.id.nil?
-        self.repository.adapter.select("select #{association.association_foreign_key} from #{association.join_table} where #{association.association_key} = #{self.id}")
+        def _t_delete(ids, run_callbacks=true)
+          objects = _t_find_bulk(ids)
+          if run_callbacks
+            objects.each { |object| object.destroy }
+          else
+            objects.each { |object| object.destroy! }
+          end
+        end
       end
 
-      private
+      module InstanceMethods #:nodoc:
+        include Tenacity::OrmExt::Helpers
+
+        # DataMapper will not issue callbacks unless at least one of the properties is dirty.
+        # So, taint the object by marking one of the attributes as dirty, save the object,
+        # and resture the persisted_state by reloading the object from the database.
+        def save
+          if clean?
+            taint!; super; reload
+          else
+            super
+          end
+        end
+
+        def _t_reload
+          reload
+        end
+
+        def _t_clear_associates(association)
+          self.repository.adapter.execute("delete from #{association.join_table} where #{association.association_key} = #{_t_serialize_id_for_sql(self.id)}")
+        end
 
-      def taint!
-        property = properties.first.name
-        self.persisted_state = ::DataMapper::Resource::State::Dirty.new(self) unless self.persisted_state.kind_of?(::DataMapper::Resource::State::Dirty)
-        self.persisted_state.original_attributes[properties[property]] = self.send(property)
+        def _t_associate_many(association, associate_ids)
+          self.transaction do
+            _t_clear_associates(association)
+            associate_ids.each do |associate_id|
+              self.repository.adapter.execute("insert into #{association.join_table} (#{association.association_key}, #{association.association_foreign_key}) values (#{_t_serialize_id_for_sql(self.id)}, #{_t_serialize_id_for_sql(associate_id)})")
+            end
+          end
+        end
+
+        def _t_get_associate_ids(association)
+          return [] if self.id.nil?
+          self.repository.adapter.select("select #{association.association_foreign_key} from #{association.join_table} where #{association.association_key} = #{_t_serialize_id_for_sql(self.id)}")
+        end
+
+        private
+
+        def taint!
+          property = properties.first.name
+          self.persisted_state = ::DataMapper::Resource::State::Dirty.new(self) unless self.persisted_state.kind_of?(::DataMapper::Resource::State::Dirty)
+          self.persisted_state.original_attributes[properties[property]] = self.send(property)
+        end
       end
-    end
 
+    end
   end
 end