tenacity 0.1.1 → 0.2.0

data/.gitignore

@@ -4,3 +4,4 @@
 rdoc/
 coverage/
 pkg/
+Gemfile.lock

data/EXTEND.rdoc

@@ -1,16 +1,23 @@
-For Tenacity to interact with an ORM, the ORM needs to be extended to support
-the methods listed below.  Beyond that, no additional configuration or code is
-necessary.  Tenacity communicates with the ORM using these methods only, so
-as long as they have been implemented and are available on the model object,
-Tenacity will be able to manage the object's relationships.
+For Tenacity to interact with a database client, the client needs to be extended
+to support the methods listed below.  Beyond that, no additional configuration
+or code is necessary.  Tenacity communicates with the client using these methods
+only, so as long as they have been implemented and are available on the model
+object, Tenacity will be able to manage the object's relationships.
 
 
 == A note about IDs
 
 An ID can be an integer, a string, or an object, depending on the database
-and ORM you are using.  To be as compatible as possible, Tenacity treats
-all IDs as strings.  So, all ORM extensions should accept strings for IDs
-as input parameters, and return strings for IDs.
+and database client you are using.  To be as compatible as possible, Tenacity
+treats all IDs as strings.  So, all database client extensions should accept
+strings for IDs as input parameters, and return strings for IDs.
+
+
+== The Association Class
+
+A few of the methods take an association as a parameter.  This association
+is an instance of the Tenacity::Association class, which can be found at
+lib/tenacity/association.rb.
 
 
 == Class Methods
@@ -35,21 +42,22 @@ and return it.  If no object could be found, return nil.
 Find all objects by the specified property name, with the specified id, and
 return them in an array.  If no objects could be found, return an empty array.
 
-  _t_initialize_has_many_association(association_id)
+  _t_initialize_has_many_association(association)
 
-Perform any ORM specific initialization necessary to support a has many
-association.  This could include defining properties, or callback methods,
+Perform any database client specific initialization necessary to support a has
+many association.  This could include defining properties, or callback methods,
 on the object.  This method is optional, and does not need to be defined.
 
-  _t_initialize_belongs_to_association(association_id)
+  _t_initialize_belongs_to_association(association)
 
-Perform any ORM specific initialization necessary to support a belongs to
-association.  This could include defining properties, or callback methods,
-on the object.  This method is optional, and does not need to be defined.
+Perform any database client specific initialization necessary to support a
+belongs to association.  This could include defining properties, or callback
+methods, on the object.  This method is optional, and does not need to be
+defined.
 
-  _t_initialize_has_one_association(association_id)
+  _t_initialize_has_one_association(association)
 
-Perform any ORM specific initialization necessary to support a has one
+Perform any database client specific initialization necessary to support a has one
 association.  This could include defining properties, or callback methods,
 on the object.  This method is optional, and does not need to be defined.
 
@@ -61,18 +69,20 @@ on the object.  This method is optional, and does not need to be defined.
 Reload the object from the database, overwriting the objects properties with
 the data fetched from the database.  Return nothing.
 
-  _t_associate_many(association_id, associate_ids)
+  _t_associate_many(association, associate_ids)
 
 Create has_many associations between this object and the objects with ids
 specified in the array of associate_ids.  This method could involve writing
-the associate_ids into a join table, or into an object's hash.
+the associate_ids into a join table, or into one of the object's properties.
+Return nothing.
 
-  _t_get_associate_ids(association_id)
+  _t_get_associate_ids(association)
 
 Get the ids of the objects associated with this object through the specified
-association, and return them in an array.
+association, and return them in an array.  Return an empty array if there
+are no associated objects.
 
-  _t_clear_associates(association_id)
+  _t_clear_associates(association)
 
 Destroy the association between this object and its current associates through
 the specified association.  Return nothing.

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010 John Wood
+Copyright (c) 2011 John Wood
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,15 +1,16 @@
 = Tenacity
 
-An ORM independent way of specifying simple relationships between models
+A database client independent way of managing relationships between models
 backed by different databases.
 
 It is sometimes necessary, or advantageous, to use more than one database in a
-given application (polyglot persistence).  However, most ORMs do not support
-inter-database relationships.  While supporting such relationships isn't difficult,
-it can add quite a bit of boilerplate code to your project.
+given application (polyglot persistence).  However, most database clients do not
+support inter-database relationships.  So, writing code that manages relationships
+between objects backed by different databases hasn’t been nearly as easy as
+writing code to manage relationships between objects in the same database.
 
-Tenacity aims to address this by providing an ORM independent way of specifying
-simple relationships between models backed by different databases.
+Tenacity aims to address this by providing a database client independent way
+of managing relationships between models backed by different databases.
 
 Tenacity is heavily based on ActiveRecord's associations, and aims to behave in
 much the same way, supporting many of the same options.
@@ -79,17 +80,18 @@ much the same way, supporting many of the same options.
 * The directories that contain your model classes must be in your load path in order for Tenacity to find them.
 
 
-== Supported ORMs
+== Supported Database Clients
 
 * ActiveRecord
 * MongoMapper
 * CouchRest (CouchModel and ExtendedDocument)
 
-See EXTEND.rdoc for information on extendeding Tenacity to work with other ORMs.
+See EXTEND.rdoc for information on extending Tenacity to work with other database clients.
 
 
 == Documentation
-* http://rdoc.info/github/jwood/tenacity/master/frames
+* http://rdoc.info/github/jwood/tenacity/master/Tenacity/ClassMethods - Documentation on the associations supported, and their respective options
+* http://rdoc.info/github/jwood/tenacity/master/frames - Full API documentation
 
 
 == Contributing to Tenacity
@@ -105,14 +107,10 @@ See EXTEND.rdoc for information on extendeding Tenacity to work with other ORMs.
 
 == Development
 
-* MySQL, MongoDB, and CouchDB must be installed and configured.
+* SQLite, MongoDB, and CouchDB must be installed and configured.
 * Install the dependencies
 
-  bundler install
-
-* Setup the test databases
-
-  rake test:prepare
+  bundle install
 
 * Run the tests
 
@@ -123,5 +121,5 @@ See EXTEND.rdoc for information on extendeding Tenacity to work with other ORMs.
 
 == Copyright
 
-Copyright (c) 2010 John Wood. See LICENSE.txt for further details.
+Copyright (c) 2011 John Wood. See LICENSE.txt for further details.
 

data/Rakefile

@@ -43,40 +43,3 @@ end
 desc 'Delete rcov, rdoc, and other generated files'
 task :clobber => [:clobber_rcov, :clobber_rdoc]
 
-begin
-  require 'test/helpers/active_record_test_helper'
-  namespace :test do
-    desc "Setup the test databases"
-    task :prepare do
-      system "mysqladmin -u root drop -f tenacity_test"
-      system "mysqladmin -u root create tenacity_test"
-
-      ActiveRecord::Schema.define :version => 0 do
-
-        create_table :active_record_cars, :force => true do |t|
-        end
-
-        create_table :active_record_climate_control_units, :force => true do |t|
-          t.string :mongo_mapper_dashboard_id
-        end
-
-        create_table :active_record_cars_mongo_mapper_wheels, :force => true do |t|
-          t.integer :active_record_car_id
-          t.string :mongo_mapper_wheel_id
-        end
-
-        create_table :active_record_nuts, :force => true do |t|
-          t.string :mongo_mapper_wheel_id
-        end
-
-        create_table :active_record_nuts_mongo_mapper_wheels, :force => true do |t|
-          t.integer :active_record_nut_id
-          t.string :mongo_mapper_wheel_id
-        end
-
-      end
-    end
-  end
-rescue LoadError
-  # No ActiveRecord
-end

data/history.txt

@@ -1,3 +1,24 @@
+== 0.2.0
+
+* Major enhancements
+
+  * Added options to override assumptions on names of classes, foreign keys,
+    tables, and columns.
+
+* Minor enhancements
+
+  * Added support for the :class_name option to all associations
+  * Added support for the :foreign_key option to all associations
+  * Added support for the :foreign_keys_property option to the t_has_many association
+  * Added support for the :join_table option to the t_has_many association
+  * Added support for the :association_foreign_key option to the t_has_many association
+  * Added support for the :association_key option to the t_has_many association
+
+* Bug fixes
+
+  * t_has_one association was being initialized on the wrong class in the association
+  * Fixed bug that causing t_has_many associations not to work with SQLite
+
 == 0.1.1
 
 * Bug fixes

data/lib/tenacity.rb

@@ -1,5 +1,6 @@
 require File.join('active_support', 'inflector')
 
+require File.join(File.dirname(__FILE__), 'tenacity', 'association')
 require File.join(File.dirname(__FILE__), 'tenacity', 'class_methods')
 require File.join(File.dirname(__FILE__), 'tenacity', 'instance_methods')
 require File.join(File.dirname(__FILE__), 'tenacity', 'associations', 'belongs_to')
@@ -20,7 +21,7 @@ module Tenacity #:nodoc:
   include HasOne
 
   def self.included(model)
-    raise "Tenacity does not support the ORM used by #{model}" unless model.respond_to?(:_t_find)
+    raise "Tenacity does not support the database client used by #{model}" unless model.respond_to?(:_t_find)
     model.extend(ClassMethods)
   end
 end

data/lib/tenacity/association.rb

@@ -0,0 +1,82 @@
+module Tenacity
+  class Association
+    # Type type of the association (<tt>:t_has_one</tt>, <tt>:t_has_many</tt>, or <tt>:t_belongs_to</tt>)
+    attr_reader :type
+
+    # The name of the association
+    attr_reader :name
+
+    # The class defining the association
+    attr_reader :source
+
+    # The name of the associated class
+    attr_reader :class_name
+
+    def initialize(type, name, source, options={})
+      @type = type
+      @name = name
+      @source = source
+
+      if options[:class_name]
+        @class_name = options[:class_name]
+      else
+        @class_name = name.to_s.singularize.camelcase
+      end
+
+      @foreign_key = options[:foreign_key]
+      @foreign_keys_property = options[:foreign_keys_property]
+      @join_table = options[:join_table]
+      @association_key = options[:association_key]
+      @association_foreign_key = options[:association_foreign_key]
+
+      if @foreign_keys_property
+        if @foreign_keys_property.to_s == ActiveSupport::Inflector.singularize(name) + "_ids"
+          raise "#{ActiveSupport::Inflector.singularize(name) + "_ids"} is an invalid foreign keys property name"
+        end
+      end
+    end
+
+    # Get the associated class
+    def associate_class
+      @clazz ||= Kernel.const_get(@class_name)
+    end
+
+    # Get the foreign key used by this association. <tt>t_has_one</tt> and
+    # <tt>t_has_many</tt> associations need the class of the associated object
+    # to be specified in order to properly determine the name of the foreign key.
+    def foreign_key(clazz=nil)
+      @foreign_key || begin
+        if @type == :t_belongs_to
+          @class_name.underscore + "_id"
+        elsif @type == :t_has_one || @type == :t_has_many
+          raise "The class of the associate must be provided in order to determine the name of the foreign key" if clazz.nil?
+          "#{ActiveSupport::Inflector.underscore(clazz)}_id"
+        end
+      end
+    end
+
+    # Get the property name used to store the foreign key
+    def foreign_keys_property
+      @foreign_keys_property || "t_" + ActiveSupport::Inflector.singularize(name) + "_ids"
+    end
+
+    # Get the name of the join table used by this association
+    def join_table
+      if @join_table || @source.respond_to?(:table_name)
+        @join_table || (name.to_s < @source.table_name ? "#{name}_#{@source.table_name}" : "#{@source.table_name}_#{name}")
+      end
+    end
+
+    # Get the name of the column in the join table that represents this object
+    def association_key
+      if @association_key || @source.respond_to?(:table_name)
+        @association_key || @source.table_name.singularize + '_id'
+      end
+    end
+
+    # Get the name of the column in the join table that represents the associated object
+    def association_foreign_key
+      @association_foreign_key || name.to_s.singularize + '_id'
+    end
+  end
+end

data/lib/tenacity/associations/belongs_to.rb

@@ -3,23 +3,23 @@ module Tenacity
 
     private
 
-    def belongs_to_associate(association_id)
-      associate_id = self.send("#{association_id}_id")
-      clazz = associate_class(association_id)
+    def belongs_to_associate(association)
+      associate_id = self.send(association.foreign_key)
+      clazz = association.associate_class
       clazz._t_find(associate_id)
     end
 
-    def set_belongs_to_associate(association_id, associate)
-      self.send "#{association_id}_id=", associate.id.to_s
+    def set_belongs_to_associate(association, associate)
+      self.send "#{association.foreign_key}=", associate.id.to_s
     end
 
     module ClassMethods #:nodoc:
-      def initialize_belongs_to_association(association_id)
-        _t_initialize_belongs_to_association(association_id) if self.respond_to?(:_t_initialize_belongs_to_association)
+      def initialize_belongs_to_association(association)
+        _t_initialize_belongs_to_association(association) if self.respond_to?(:_t_initialize_belongs_to_association)
       end
 
-      def _t_stringify_belongs_to_value(record, association_id)
-        record.send "#{association_id}_id=", record.send("#{association_id}_id").to_s
+      def _t_stringify_belongs_to_value(record, association)
+        record.send "#{association.foreign_key}=", record.send(association.foreign_key).to_s
       end
     end
 

data/lib/tenacity/associations/has_many.rb

@@ -3,19 +3,19 @@ module Tenacity
 
     private
 
-    def has_many_associates(association_id)
-      ids = _t_get_associate_ids(association_id)
-      clazz = associate_class(association_id)
+    def has_many_associates(association)
+      ids = _t_get_associate_ids(association)
+      clazz = association.associate_class
       clazz._t_find_bulk(ids)
     end
 
-    def has_many_associate_ids(association_id)
-      _t_get_associate_ids(association_id)
+    def has_many_associate_ids(association)
+      _t_get_associate_ids(association)
     end
 
-    def set_has_many_associate_ids(association_id, associate_ids)
-      clazz = associate_class(association_id)
-      instance_variable_set ivar_name(association_id), clazz._t_find_bulk(associate_ids)
+    def set_has_many_associate_ids(association, associate_ids)
+      clazz = association.associate_class
+      instance_variable_set _t_ivar_name(association), clazz._t_find_bulk(associate_ids)
     end
 
     def save_without_callback
@@ -25,38 +25,34 @@ module Tenacity
       @perform_save_associates_callback = true
     end
 
-    def has_many_property_name(association_id)
-      self.class.has_many_property_name(association_id)
-    end
-
     module ClassMethods #:nodoc:
-      def initialize_has_many_association(association_id)
-        _t_initialize_has_many_association(association_id) if self.respond_to?(:_t_initialize_has_many_association)
+      def initialize_has_many_association(association)
+        _t_initialize_has_many_association(association) if self.respond_to?(:_t_initialize_has_many_association)
 
         attr_accessor :perform_save_associates_callback
       end
 
-      def _t_save_associates(record, association_id)
+      def _t_save_associates(record, association)
         return if record.perform_save_associates_callback == false
 
-        _t_clear_old_associations(record, association_id)
+        _t_clear_old_associations(record, association)
 
-        associates = (record.instance_variable_get "@_t_#{association_id.to_s}") || []
+        associates = (record.instance_variable_get record._t_ivar_name(association)) || []
         associates.each do |associate|
-          associate.send("#{property_name_for_record(record)}=", record.id.to_s)
+          associate.send("#{association.foreign_key(record.class)}=", record.id.to_s)
           save_associate(associate)
         end
 
         unless associates.blank?
           associate_ids = associates.map { |associate| associate.id.to_s }
-          record._t_associate_many(association_id, associate_ids)
+          record._t_associate_many(association, associate_ids)
           save_associate(record)
         end
       end
 
-      def _t_clear_old_associations(record, association_id)
-        clazz = associate_class(association_id)
-        property_name = property_name_for_record(record)
+      def _t_clear_old_associations(record, association)
+        clazz = association.associate_class
+        property_name = association.foreign_key(record.class)
 
         old_associates = clazz._t_find_all_by_associate(property_name, record.id.to_s)
         old_associates.each do |old_associate|
@@ -64,18 +60,10 @@ module Tenacity
           save_associate(old_associate)
         end
 
-        record._t_clear_associates(association_id)
+        record._t_clear_associates(association)
         save_associate(record)
       end
 
-      def property_name_for_record(record)
-        "#{ActiveSupport::Inflector.underscore(record.class.to_s)}_id"
-      end
-
-      def has_many_property_name(association_id)
-        "t_" + ActiveSupport::Inflector.singularize(association_id) + "_ids"
-      end
-
       def save_associate(associate)
         associate.respond_to?(:_t_save_without_callback) ? associate._t_save_without_callback : associate.save
       end