tenacity 0.2.0 → 0.3.0

data/lib/tenacity/orm_ext/couchrest.rb

@@ -0,0 +1,140 @@
+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
+
+      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
+
+      # 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
+    end
+
+    module ClassMethods #:nodoc:
+      def _t_find(id)
+        (id.nil? || id.strip == "") ? nil : get(id)
+      end
+
+      def _t_find_bulk(ids)
+        return [] if ids.nil? || ids.empty?
+
+        docs = []
+        result = database.get_bulk 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_find_first_by_associate(property, id)
+        self.send("by_#{property}", :key => id.to_s).first
+      end
+
+      def _t_find_all_by_associate(property, id)
+        self.send("by_#{property}", :key => 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 => [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) }
+        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) }
+        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) }
+        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_associate_many(association, associate_ids)
+        self.send(association.foreign_keys_property + '=', associate_ids.map { |associate_id| associate_id.to_s })
+      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

data/lib/tenacity/orm_ext/datamapper.rb

@@ -0,0 +1,139 @@
+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
+      end
+    rescue LoadError
+      # DataMapper not available
+    end
+
+    module ClassMethods #:nodoc:
+      def _t_find(id)
+        get(id)
+      end
+
+      def _t_find_bulk(ids)
+        return [] if ids.nil? || ids.empty?
+        all(:id => ids)
+      end
+
+      def _t_find_first_by_associate(property, id)
+        first(property => id.to_s)
+      end
+
+      def _t_find_all_by_associate(property, id)
+        all(property => id.to_s)
+      end
+
+      def _t_initialize_has_many_association(association)
+        after :save do |record|
+          record.class._t_save_associates(record, association)
+        end
+      end
+
+      def _t_initialize_belongs_to_association(association)
+        before :save do |record|
+          record.class._t_stringify_belongs_to_value(record, association)
+        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! }
+        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
+        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} = #{self.id}")
+      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}')")
+          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}")
+      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

data/lib/tenacity/orm_ext/mongo_mapper.rb

@@ -1,97 +1,105 @@
-# Tenacity relationships on MongoMapper 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 < ActiveRecord::Base
-#     include MongoMapper::Document
-#     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 key named after the association.
-# The example above will create a key named <tt>:driver_id</tt>
-#
-#
-# == t_has_one
-#
-# The +t_has_one+ association will not define any new keys on the object, since
-# the associated object holds the foreign key.
-#
-#
-# == t_has_many
-#
-# The +t_has_many+ association will define a key named after the association.
-# The example above will create a key named <tt>:wheels_ids</tt>
-#
-module TenacityMongoMapperPlugin
-  module ClassMethods #:nodoc:
-    def _t_find(id)
-      find(id)
-    end
+module Tenacity
+  # Tenacity relationships on MongoMapper 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 < ActiveRecord::Base
+  #     include MongoMapper::Document
+  #     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 key named after the association.
+  # The example above will create a key named <tt>:driver_id</tt>
+  #
+  #
+  # == t_has_one
+  #
+  # The +t_has_one+ association will not define any new keys on the object, since
+  # the associated object holds the foreign key.
+  #
+  #
+  # == t_has_many
+  #
+  # The +t_has_many+ association will define a key named after the association.
+  # The example above will create a key named <tt>:wheels_ids</tt>
+  #
+  module MongoMapper
 
-    def _t_find_bulk(ids=[])
-      find(ids)
+    def self.setup(model) #:nodoc:
+      require 'mongo_mapper'
+      if model.included_modules.include?(::MongoMapper::Document)
+        model.send :include, MongoMapper::InstanceMethods
+        model.extend MongoMapper::ClassMethods
+      end
+    rescue LoadError
+      # MongoMapper not available
     end
 
-    def _t_find_first_by_associate(property, id)
-      first(property => id.to_s)
-    end
+    module ClassMethods #:nodoc:
+      def _t_find(id)
+        find(id)
+      end
 
-    def _t_find_all_by_associate(property, id)
-      all(property => id.to_s)
-    end
+      def _t_find_bulk(ids=[])
+        find(ids)
+      end
 
-    def _t_initialize_has_many_association(association)
-      unless self.respond_to?(association.foreign_keys_property)
-        key association.foreign_keys_property, Array
-        after_save { |record| _t_save_associates(record, association) }
+      def _t_find_first_by_associate(property, id)
+        first(property => id.to_s)
       end
-    end
 
-    def _t_initialize_belongs_to_association(association)
-      unless self.respond_to?(association.foreign_key)
-        key association.foreign_key, String
-        before_save { |record| _t_stringify_belongs_to_value(record, association) }
+      def _t_find_all_by_associate(property, id)
+        all(property => id.to_s)
       end
-    end
-  end
 
-  module InstanceMethods #:nodoc:
-    def _t_reload
-      reload
-    rescue MongoMapper::DocumentNotFound
-      nil
-    end
+      def _t_initialize_has_many_association(association)
+        unless self.respond_to?(association.foreign_keys_property)
+          key association.foreign_keys_property, Array
+          after_save { |record| _t_save_associates(record, association) }
+        end
+      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_belongs_to_association(association)
+        unless self.respond_to?(association.foreign_key)
+          key association.foreign_key, String
+          before_save { |record| _t_stringify_belongs_to_value(record, association) }
+        end
+      end
 
-    def _t_get_associate_ids(association)
-      self.send(association.foreign_keys_property)
+      def _t_delete(ids, run_callbacks=true)
+        if run_callbacks
+          destroy(ids)
+        else
+          delete(ids)
+        end
+      end
     end
 
-    def _t_clear_associates(association)
-      self.send(association.foreign_keys_property + '=', [])
+    module InstanceMethods #:nodoc:
+      def _t_reload
+        reload
+      rescue ::MongoMapper::DocumentNotFound
+        nil
+      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_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
 
-module TenacityPluginAddition #:nodoc:
-  def self.included(model)
-    model.plugin TenacityMongoMapperPlugin
   end
 end
-
-begin
-  require 'mongo_mapper'
-  MongoMapper::Document.append_inclusions(TenacityPluginAddition)
-rescue LoadError
-  # MongoMapper not available
-end
-