tenacity 0.1.1 → 0.2.0

data/lib/tenacity/associations/has_one.rb

@@ -3,35 +3,19 @@ module Tenacity
 
     private
 
-    def has_one_associate(association_id)
-      clazz = associate_class(association_id)
-      clazz._t_find_first_by_associate(property_name, self.id.to_s)
+    def has_one_associate(association)
+      clazz = association.associate_class
+      clazz._t_find_first_by_associate(association.foreign_key(self.class), self.id.to_s)
     end
 
-    def set_has_one_associate(association_id, associate)
-      associate.send "#{property_name}=", self.id.to_s
+    def set_has_one_associate(association, associate)
+      associate.send "#{association.foreign_key(self.class)}=", self.id.to_s
       associate.save
     end
 
-    def property_name
-      "#{ActiveSupport::Inflector.underscore(self.class.to_s)}_id"
-    end
-
     module ClassMethods #:nodoc:
-      def initialize_has_one_association(association_id)
-        begin
-          require association_id.to_s
-        rescue Exception => e
-          puts "ERROR: #{association_id.to_s} does not appear to be in the load path. Please make sure all model files are in the load path."
-          raise
-        end
-
-        clazz = associate_class(association_id)
-        clazz._t_initialize_has_one_association(ActiveSupport::Inflector.underscore(self.to_s)) if clazz.respond_to?(:_t_initialize_has_one_association)
-      end
-
-      def _t_stringify_has_one_value(record, association_id)
-        record.send "#{association_id}_id=", record.send("#{association_id}_id").to_s
+      def initialize_has_one_association(association)
+        _t_initialize_has_one_association(association) if respond_to?(:_t_initialize_has_one_association)
       end
     end
 

data/lib/tenacity/class_methods.rb

@@ -70,6 +70,32 @@ module Tenacity
   #   project.milestones(true).size  # fetches milestones from the database
   #   project.milestones             # uses the milestone cache
   #
+  # == Join Tables
+  #
+  # One-to-many assocations that contain a relational database backed object as one of
+  # the assocaites are implemented using an intermediate join table. This differs from
+  # ActiveRecord::Associations, where only many-to-many relationships are implemented
+  # using an intermediate join table.
+  #
+  # Tenacity will not create the join table. It assume one exists, and is named properly.
+  # Unless the join table is explicitly specified as an option, it is guessed using the
+  # lexical order of the class names. So a join between Developer and Project will give
+  # the default join table name of "developers_projects" because "D" outranks "P". Note
+  # that this precedence is calculated using the < operator for String. This means that
+  # if the strings are of different lengths, and the strings are equal when compared up
+  # to the shortest length, then the longer string is considered of higher lexical
+  # precedence than the shorter one. For example, one would expect the tables "paper_boxes"
+  # and "papers" to generate a join table name of "papers_paper_boxes" because of the
+  # length of the name "paper_boxes", but it in fact generates a join table name of
+  # "paper_boxes_papers". Be aware of this caveat, and use the custom :join_table option
+  # if you need to.
+  #
+  # The column names used in the join table are guessed to be the names of the associated
+  # classes, suffixed with "_id".  For example, the "developers_projects" join table
+  # mentioned above is expected to have a column named "developer_id" and a column named
+  # "project_id". The <tt>:associate_key</tt> and <tt>:associate_foreign_key</tt> options
+  # can be used to override these defaults.
+  #
   module ClassMethods
 
     # Specifies a one-to-one association with another class. This method should only be used
@@ -93,19 +119,34 @@ module Tenacity
     # * <tt>Account#beneficiary</tt> (similar to <tt>Beneficiary.find(:first, :conditions => "account_id = #{id}")</tt>)
     # * <tt>Account#beneficiary=(beneficiary)</tt> (similar to <tt>beneficiary.account_id = account.id; beneficiary.save</tt>)
     #
-    def t_has_one(association_id, args={})
+    # === Supported options
+    # [:class_name]
+    #   Specify the class name of the association. Use it only if that name can't be inferred
+    #   from the association name. So <tt>t_has_one :manager</tt> will by default be linked to the Manager class, but
+    #   if the real class name is Person, you'll have to specify it with this option.
+    # [:foreign_key]
+    #   Specify the foreign key used for the association. By default this is guessed to be the name
+    #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +t_has_one+ association
+    #   will use "person_id" as the default <tt>:foreign_key</tt>.
+    #
+    # Option examples:
+    #   t_has_one :project_manager, :class_name => "Person"
+    #   t_has_one :project_manager, :foreign_key => "project_id"  # within class named SecretProject
+    #
+    def t_has_one(name, options={})
       extend(HasOne::ClassMethods)
-      initialize_has_one_association(association_id)
+      association = Association.new(:t_has_one, name, self, options)
+      initialize_has_one_association(association)
 
-      define_method(association_id) do |*params|
-        get_associate(association_id, params) do
-          has_one_associate(association_id)
+      define_method(association.name) do |*params|
+        get_associate(association, params) do
+          has_one_associate(association)
         end
       end
 
-      define_method("#{association_id}=") do |associate|
-        set_associate(association_id, associate) do
-          set_has_one_associate(association_id, associate)
+      define_method("#{association.name}=") do |associate|
+        set_associate(association, associate) do
+          set_has_one_associate(association, associate)
         end
       end
     end
@@ -131,25 +172,46 @@ module Tenacity
     # * <tt>Post#author</tt> (similar to <tt>Author.find(author_id)</tt>)
     # * <tt>Post#author=(author)</tt> (similar to <tt>post.author_id = author.id</tt>)
     #
-    def t_belongs_to(association_id, args={})
+    # === Supported options
+    # [:class_name]
+    #   Specify the class name of the association. Use it only if that name can't be inferred
+    #   from the association name. So <tt>t_belongs_to :manager</tt> will by default be linked to the Manager class, but
+    #   if the real class name is Person, you'll have to specify it with this option.
+    # [:foreign_key]
+    #   Specify the foreign key used for the association. By default this is guessed to be the name
+    #   of the association with an "_id" suffix. So a class that defines a <tt>t_belongs_to :person</tt>
+    #   association will use "person_id" as the default <tt>:foreign_key</tt>. Similarly,
+    #   <tt>t_belongs_to :favorite_person, :class_name => "Person"</tt> will use a foreign key
+    #   of "favorite_person_id".
+    #
+    # Option examples:
+    #   t_belongs_to :project_manager, :class_name => "Person"
+    #   t_belongs_to :valid_coupon, :class_name => "Coupon", :foreign_key => "coupon_id"
+    #
+    def t_belongs_to(name, options={})
       extend(BelongsTo::ClassMethods)
-      initialize_belongs_to_association(association_id)
+      association = Association.new(:t_belongs_to, name, self, options)
+      initialize_belongs_to_association(association)
 
-      define_method(association_id) do |*params|
-        get_associate(association_id, params) do
-          belongs_to_associate(association_id)
+      define_method(association.name) do |*params|
+        get_associate(association, params) do
+          belongs_to_associate(association)
         end
       end
 
-      define_method("#{association_id}=") do |associate|
-        set_associate(association_id, associate) do
-          set_belongs_to_associate(association_id, associate)
+      define_method("#{association.name}=") do |associate|
+        set_associate(association, associate) do
+          set_belongs_to_associate(association, associate)
         end
       end
     end
 
-    # Specifies a one-to-many association. The following methods for retrieval and query of
-    # collections of associated objects will be added:
+    # Specifies a one-to-many association. One-to-many associations that contain a
+    # relational database backed object as one of the associates are implemented
+    # using an intermediate join table. See the Join Tables section at the top
+    # for more information.
+    #
+    # The following methods for retrieval and query of collections of associated objects will be added:
     #
     # [collection(force_reload = false)]
     #   Returns an array of all the associated objects.
@@ -188,26 +250,71 @@ module Tenacity
     # * <tt>Firm#clients.empty?</tt> (similar to <tt>firm.clients.size == 0</tt>)
     # * <tt>Firm#clients.size</tt> (similar to <tt>Client.count "firm_id = #{id}"</tt>)
     #
-    def t_has_many(association_id, args={})
+    # === Supported options
+    # [:class_name]
+    #   Specify the class name of the association. Use it only if that name can't be inferred
+    #   from the association name. So <tt>t_has_many :products</tt> will by default be linked
+    #   to the Product class, but if the real class name is SpecialProduct, you'll have to
+    #   specify it with this option.
+    # [:foreign_key]
+    #   Specify the foreign key used for the association. By default this is guessed to be the name
+    #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +t_has_many+
+    #   association will use "person_id" as the default <tt>:foreign_key</tt>.
+    # [:foreign_keys_property]
+    #   Specify the name of the property that stores the ids of the associated objects. By default
+    #   this is guessed to be the name of the association with a "t_" prefix and an "_ids" suffix.
+    #   So a class that defines a <tt>t_has_many :people</tt> association will use t_people_ids as
+    #   the property to store the ids of the associated People objects. This option is only valid
+    #   for objects that store associated ids in an array instaed of a join table (CouchRest,
+    #   MongoMapper, etc). <b>WARNING:</b> The name of the association with an "_ids" suffix should
+    #   not be used as the property name, since tenacity adds a method with this name to the object.
+    # [:join_table]
+    #   Specify the name of the join table if the default based on lexical order isn't what you want.
+    #   This option is only valid if one of the models in the association is backed by a relational
+    #   database.
+    # [:association_foreign_key]
+    #   Specify the foreign key in the join table used for the association on the receiving side of
+    #   the association. By default this is guessed to be the name of the associated class in
+    #   lower-case and "_id" suffixed. So if a Person class makes a +t_has_many+ association to
+    #   Project, the association will use "project_id" as the default <tt>:association_foreign_key</tt>.
+    #   This option is only valid if one of the associated objects is backed by a relational
+    #   database.
+    # [:association_key]
+    #   Specify the key in the join table used for the association on the declaring side of
+    #   the association. By default this is guessed to be the name of this class in lower-case and
+    #   "_id" suffixed. So if a Person class makes a +t_has_many+ association to Project, the
+    #   association will use "person_id" as the default <tt>:association_key</tt>.  This option is
+    #   only valid if one of the associated objects is backed by a relational database.
+    #
+    # Option examples:
+    #   t_has_many :products, :class_name => "SpecialProduct"
+    #   t_has_many :engineers, :foreign_key => "project_id"  # within class named SecretProject
+    #   t_has_many :engineers, :foreign_keys_property => "worker_ids"
+    #   t_has_many :managers, :join_table => "project_managers_and_projects"
+    #   t_has_many :managers, :join_table => "project_managers_and_projects",
+    #       :association_foreign_key => "mgr_id", :association_key => "proj_id"
+    #
+    def t_has_many(name, options={})
       extend(HasMany::ClassMethods)
-      initialize_has_many_association(association_id)
+      association = Association.new(:t_has_many, name, self, options)
+      initialize_has_many_association(association)
 
-      define_method(association_id) do |*params|
-        get_associate(association_id, params) do
-          has_many_associates(association_id)
+      define_method(association.name) do |*params|
+        get_associate(association, params) do
+          has_many_associates(association)
         end
       end
 
-      define_method("#{association_id}=") do |associates|
-        set_associate(association_id, associates)
+      define_method("#{association.name}=") do |associates|
+        set_associate(association, associates)
       end
 
-      define_method("#{ActiveSupport::Inflector.singularize(association_id.to_s)}_ids") do
-        has_many_associate_ids(association_id)
+      define_method("#{ActiveSupport::Inflector.singularize(association.name)}_ids") do
+        has_many_associate_ids(association)
       end
 
-      define_method("#{ActiveSupport::Inflector.singularize(association_id.to_s)}_ids=") do |associate_ids|
-        set_has_many_associate_ids(association_id, associate_ids)
+      define_method("#{ActiveSupport::Inflector.singularize(association.name)}_ids=") do |associate_ids|
+        set_has_many_associate_ids(association, associate_ids)
       end
 
       private
@@ -217,10 +324,6 @@ module Tenacity
       end
     end
 
-    def associate_class(association_id) #:nodoc:
-      Kernel.const_get(association_id.to_s.singularize.camelcase.to_sym)
-    end
-
   end
 end
 

data/lib/tenacity/instance_methods.rb

@@ -1,30 +1,26 @@
 module Tenacity
   module InstanceMethods #:nodoc:
 
+    def _t_ivar_name(association)
+      "@_t_" + association.name.to_s
+    end
+
     private
 
-    def get_associate(association_id, params)
+    def get_associate(association, params)
       _t_reload
       force_reload = params.first unless params.empty?
-      value = instance_variable_get ivar_name(association_id)
+      value = instance_variable_get _t_ivar_name(association)
       if value.nil? || force_reload
         value = yield
-        instance_variable_set ivar_name(association_id), value
+        instance_variable_set _t_ivar_name(association), value
       end
       value
     end
 
-    def set_associate(association_id, associate)
+    def set_associate(association, associate)
       yield if block_given?
-      instance_variable_set ivar_name(association_id), associate
-    end
-
-    def ivar_name(association_id)
-      "@_t_" + association_id.to_s
-    end
-
-    def associate_class(association_id)
-      self.class.associate_class(association_id)
+      instance_variable_set _t_ivar_name(association), associate
     end
 
   end

data/lib/tenacity/orm_ext/activerecord.rb

@@ -62,53 +62,36 @@ begin
         find(:all, :conditions => ["#{property} = ?", id.to_s])
       end
 
-      def self._t_initialize_has_many_association(association_id)
-        after_save { |record| record.class._t_save_associates(record, association_id) }
+      def self._t_initialize_has_many_association(association)
+        after_save { |record| record.class._t_save_associates(record, association) }
       end
 
-      def self._t_initialize_belongs_to_association(association_id)
-        before_save { |record| record.class._t_stringify_belongs_to_value(record, association_id) }
+      def self._t_initialize_belongs_to_association(association)
+        before_save { |record| record.class._t_stringify_belongs_to_value(record, association) }
       end
 
       def _t_reload
         reload
       end
 
-      def _t_clear_associates(association_id)
-        t_join_table_name = self.class._t_join_table_name(association_id)
-        self.connection.execute("delete from #{t_join_table_name} where #{self.class._t_my_id_column} = #{self.id}")
+      def _t_clear_associates(association)
+        self.connection.execute("delete from #{association.join_table} where #{association.association_key} = #{self.id}")
       end
 
-      def _t_associate_many(association_id, associate_ids)
-        t_join_table_name = self.class._t_join_table_name(association_id)
-        values = associate_ids.map { |associate_id| "(#{self.id}, '#{associate_id}')" }.join(',')
-
+      def _t_associate_many(association, associate_ids)
         self.transaction do
-          _t_clear_associates(association_id)
-          self.connection.execute("insert into #{t_join_table_name} (#{self.class._t_my_id_column}, #{self.class._t_associate_id_column(association_id)}) values #{values}")
+          _t_clear_associates(association)
+          associate_ids.each do |associate_id|
+            self.connection.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_id)
-        t_join_table_name = self.class._t_join_table_name(association_id)
-        rows = self.connection.execute("select #{self.class._t_associate_id_column(association_id)} from #{t_join_table_name} where #{self.class._t_my_id_column} = #{self.id}")
+      def _t_get_associate_ids(association)
+        rows = self.connection.execute("select #{association.association_foreign_key} from #{association.join_table} where #{association.association_key} = #{self.id}")
         ids = []; rows.each { |r| ids << r[0] }; ids
       end
 
-      private
-
-      def self._t_my_id_column
-        table_name.singularize + '_id'
-      end
-
-      def self._t_associate_id_column(association_id)
-        association_id.to_s.singularize + '_id'
-      end
-
-      def self._t_join_table_name(association_id)
-        association_id.to_s < table_name ? "#{association_id}_#{table_name}" : "#{table_name}_#{association_id}"
-      end
-
     end
   end
 rescue LoadError

data/lib/tenacity/orm_ext/couchrest/couchrest_extended_document.rb

@@ -24,10 +24,7 @@ begin
     # == 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.  If the CouchRest::ExtendedDocument class
-    # is the target of a t_has_one association from another class, then a property
-    # named after the association will be created on the CouchRest::ExtendedDocument object to
-    # hold the foreign key to the other object.
+    # the associated object holds the foreign key.
     #
     #
     # == t_has_many

data/lib/tenacity/orm_ext/couchrest/couchrest_model.rb

@@ -25,10 +25,7 @@ begin
       # == 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.  If the CouchRest::Model class
-      # is the target of a t_has_one association from another class, then a property
-      # named after the association will be created on the CouchRest::Model object to
-      # hold the foreign key to the other object.
+      # the associated object holds the foreign key.
       #
       #
       # == t_has_many

data/lib/tenacity/orm_ext/couchrest/tenacity_class_methods.rb

@@ -23,29 +23,20 @@ module CouchRest
       self.send("by_#{property}", :key => id.to_s)
     end
 
-    def _t_initialize_has_many_association(association_id)
-      unless self.respond_to?(has_many_property_name(association_id))
-        property has_many_property_name(association_id), :type => [String]
-        view_by has_many_property_name(association_id)
-        after_save { |record| record.class._t_save_associates(record, association_id) if record.class.respond_to?(:_t_save_associates) }
+    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_id)
-      property_name = "#{association_id}_id"
+    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_id) if self.respond_to?(:_t_stringify_belongs_to_value) }
-      end
-    end
-
-    def _t_initialize_has_one_association(association_id)
-      property_name = "#{association_id}_id"
-      unless self.respond_to?(property_name)
-        property property_name, :type => String
-        view_by property_name
-        before_save { |record| _t_stringify_has_one_value(record, association_id) if self.respond_to?(:_t_stringify_has_one_value) }
+        before_save { |record| _t_stringify_belongs_to_value(record, association) if self.respond_to?(:_t_stringify_belongs_to_value) }
       end
     end
   end

data/lib/tenacity/orm_ext/couchrest/tenacity_instance_methods.rb

@@ -6,16 +6,16 @@ module CouchRest
       new_doc.each { |k,v| self[k] = new_doc[k] }
     end
 
-    def _t_associate_many(association_id, associate_ids)
-      self.send(has_many_property_name(association_id) + '=', associate_ids.map { |associate_id| associate_id.to_s })
+    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_id)
-      self.send(has_many_property_name(association_id)) || []
+    def _t_get_associate_ids(association)
+      self.send(association.foreign_keys_property) || []
     end
 
-    def _t_clear_associates(association_id)
-      self.send(has_many_property_name(association_id) + '=', [])
+    def _t_clear_associates(association)
+      self.send(association.foreign_keys_property + '=', [])
     end
   end
 end