acts-as-joinable 0.0.6 → 0.1.0

data/README.markdown

@@ -96,4 +96,6 @@ The features are:
 
 You can always add columns to the relationship table, but the foundation is set.
 
-<cite>copyright @viatropos 2010</cite>
+<cite>copyright @viatropos 2010</cite>
+
+http://rors.org/2008/10/26/dont-escape-in-strings

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/gempackagetask'
 spec = Gem::Specification.new do |s|
   s.name              = "acts-as-joinable"
   s.authors           = ["Lance Pollard"]
-  s.version           = "0.0.6"
+  s.version           = "0.1.0"
   s.summary           = "ActsAsJoinable: DRYing up Many-to-Many Relationships in ActiveRecord"
   s.homepage          = "http://github.com/viatropos/acts-as-joinable"
   s.email             = "lancejpollard@gmail.com"

data/lib/acts-as-joinable.rb

@@ -70,6 +70,9 @@ module ActsAsJoinable
     def acts_as_relationship
       belongs_to :parent, :polymorphic => true
       belongs_to :child,  :polymorphic => true
+      
+#      validates_uniqueness_of :parent_id, :scope => [:parent_type, :child_id]
+#      validates_uniqueness_of :child_id, :scope => [:child_type, :parent_id]
 
 #      ActsAsJoinable.models.each do |m|
 #        belongs_to "parent_#{m}".intern, :foreign_key => 'parent_id', :class_name => m.camelize

data/lib/acts_as_joinable/active_record_patch.rb

@@ -1,4 +1,64 @@
 module ActiveRecord
+  module AssociationPreload
+    module ClassMethods
+      def find_associated_records(ids, reflection, preload_options)
+        options = reflection.options
+        table_name = reflection.klass.quoted_table_name
+
+        if interface = reflection.options[:as]
+          conditions = "#{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_id"} #{in_or_equals_for_ids(ids)} and #{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_type"} IN ('#{self.name}','#{self.base_class.sti_name}')"
+        else
+          foreign_key = reflection.primary_key_name
+          conditions = "#{reflection.klass.quoted_table_name}.#{foreign_key} #{in_or_equals_for_ids(ids)}"
+        end
+
+        conditions << append_conditions(reflection, preload_options)
+
+        reflection.klass.with_exclusive_scope do
+          reflection.klass.find(:all,
+                              :select => (preload_options[:select] || options[:select] || "#{table_name}.*"),
+                              :include => preload_options[:include] || options[:include],
+                              :conditions => [conditions, ids],
+                              :joins => options[:joins],
+                              :group => preload_options[:group] || options[:group],
+                              :order => preload_options[:order] || options[:order])
+        end
+      end
+      
+      def preload_through_records(records, reflection, through_association)
+        through_reflection = reflections[through_association]
+        through_primary_key = through_reflection.primary_key_name
+
+        if reflection.options[:source_type]
+          interface = reflection.source_reflection.options[:foreign_type]
+          preload_options = {:conditions => ["#{connection.quote_column_name interface} IN (?)", reflection.options[:source_type]]}
+          
+          records.compact!
+          records.first.class.preload_associations(records, through_association, preload_options)
+
+          # Dont cache the association - we would only be caching a subset
+          through_records = []
+          records.each do |record|
+            proxy = record.send(through_association)
+
+            if proxy.respond_to?(:target)
+              through_records << proxy.target
+              proxy.reset
+            else # this is a has_one :through reflection
+              through_records << proxy if proxy
+            end
+          end
+          through_records.flatten!
+        else
+          records.first.class.preload_associations(records, through_association)
+          through_records = records.map {|record| record.send(through_association)}.flatten
+        end
+        through_records.compact!
+        through_records
+      end
+    end
+  end
+  
   module Associations
     class HasManyThroughAssociation < HasManyAssociation
       protected

data/lib/acts_as_joinable/core.rb

@@ -74,8 +74,10 @@ module ActsAsJoinable
         
         # parent, child, or contexts (both) for custom helper getters/setters
         
-        has_many :parent_relationships, :class_name => 'ActsAsJoinable::Relationship', :as => :child, :dependent => :destroy, :foreign_key => "child_id", :uniq => true
-        has_many :child_relationships,  :class_name => 'ActsAsJoinable::Relationship', :as => :parent, :dependent => :destroy, :foreign_key => "parent_id", :uniq => true
+        has_many :parent_relationships, :class_name => 'ActsAsJoinable::Relationship', :as => :child, :foreign_key => "child_id", :uniq => true
+        has_many :child_relationships,  :class_name => 'ActsAsJoinable::Relationship', :as => :parent, :foreign_key => "parent_id", :uniq => true
+        
+        after_destroy :destroy_relationships unless after_destroy.map(&:method).include?(:destroy_relationships)
         
         related_classes = (ancestors.reverse - included_modules + send(:subclasses)).uniq
         wanted_classes = []
@@ -103,20 +105,6 @@ module ActsAsJoinable
             :conditions => sql
           }
           
-          has_both_relationships = relationships.length > 1
-          
-          # don't know how to do this with has_many, since the join model requires 2
-          # different polymorphic models, and it breaks if they're the same class
-          if has_both_relationships
-            # you can only get all objects by this, method.
-            # to create them, use `child_(posts)`, `parent_(posts)`, etc.
-#            define_method type do
-#              [:parent, :child].map do |relationship|
-#                send("#{relationship.to_s}_#{type.to_s}") if respond_to?("#{relationship.to_s}_#{type.to_s}")
-#              end.flatten.compact.uniq
-#            end
-          end
-          
           # relationships == [:parent, :child]
           relationships.each do |relationship|
             relationship = opposite_for(relationship)
@@ -151,8 +139,7 @@ module ActsAsJoinable
               through_options = {
                 :class_name => "ActsAsJoinable::Relationship",
                 :conditions => conditions,
-                :as => opposite_for(relationship).to_sym,
-                :dependent => :destroy
+                :as => opposite_for(relationship).to_sym
               }
               
               through_options[:uniq] = true unless association_type == :has_one
@@ -172,11 +159,9 @@ module ActsAsJoinable
             options.delete(:uniq) if association_type == :has_one
             
             method_scope = association_type == :has_one ? :protected : :public
-            send(method_scope)
+            #send(method_scope)
             # has_many :child_users, :through => :child_relationships
-            add_association(relationship.to_s, plural_type, options, join_context, join_value, &block)
-            
-            accepts_nested_attributes_for plural_type if nestable
+            add_association(relationship.to_s, plural_type, options, join_context, join_value, nestable, &block)
             
             if association_type == :has_one
               define_method singular_type do
@@ -207,7 +192,7 @@ module ActsAsJoinable
         role.to_s == "parent" ? "child" : "parent"
       end
       
-      def add_association(relationship, plural_type, options, join_context, join_value, &block)
+      def add_association(relationship, plural_type, options, join_context, join_value, nestable, &block)
         eval_options = {:context => join_context}
         eval_options[:value] = join_value unless join_value.blank?
         send(:has_many, "#{relationship}_#{plural_type}".to_sym, options) do
@@ -218,20 +203,27 @@ module ActsAsJoinable
           EOF
         end
         # has_many :users, :through => :child_relationships
-        send(:has_many, plural_type, options) do
-          class_eval <<-EOF
-            def construct_join_attributes(associate)
-              super.merge(#{eval_options.inspect})
-            end
-          EOF
+        
+        unless self.reflect_on_all_associations.map(&:name).include?(plural_type.to_sym)
+          send(:has_many, plural_type.to_sym, options) do
+            class_eval <<-EOF
+              def construct_join_attributes(associate)
+                super.merge(#{eval_options.inspect})
+              end
+            EOF
+          end
+            
+          accepts_nested_attributes_for plural_type.to_sym if nestable
         end
       end
       
     end
     
     module InstanceMethods
-      
-      
+      def destroy_relationships
+        conditions = %Q|(`relationships`.parent_type IN ("#{self.class.name}","#{self.class.base_class.name}") AND `relationships`.parent_id = #{self.id}) OR (`relationships`.child_type IN ("#{self.class.name}","#{self.class.base_class.name}") AND `relationships`.child_id = #{self.id})|
+        ActsAsJoinable::Relationship.delete_all(conditions)
+      end
     end
   end
 end

data/test/test_acts_as_joinable.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class ActsAsJoinableTest < ActiveSupport::TestCase
+class ActsAsJoinableTest < ActiveRecord::TestCase
   
   context "ActsAsJoinable" do
     
@@ -67,6 +67,25 @@ class ActsAsJoinableTest < ActiveSupport::TestCase
         assert_equal 1, Asset.count
       end
       
+      should "have optimized sql calls" do
+        ActsAsJoinable::Relationship.delete_all
+        group = Group.create!
+        group.posts << Post.create!
+        group.posts << Post.create!
+        assert_queries(1) { Group.all }
+        assert_queries(1) { Group.first }
+        assert_queries(2) do
+          Group.first(:include => [:parent_relationships])
+        end
+        
+        # parent, child, and self
+        assert_queries(2) do
+          group.destroy
+        end
+        
+        assert_equal 0, ActsAsJoinable::Relationship.count
+      end
+      
       teardown do
         destroy_models
       end

data/test/test_helper.rb

@@ -26,7 +26,7 @@ require "#{this}/lib/group"
 
 ActiveRecord::Base.class_eval do
   def self.detonate
-    all.map(&:destroy)
+    delete_all
   end
 end
 
@@ -55,4 +55,16 @@ ActiveSupport::TestCase.class_eval do
     Group.detonate
     Asset.detonate
   end
+end
+
+ActiveRecord::Base.connection.class.class_eval do
+  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
+
+  def execute_with_query_record(sql, name = nil, &block)
+    $queries_executed ||= []
+    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+    execute_without_query_record(sql, name, &block)
+  end
+
+  alias_method_chain :execute, :query_record
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-joinable
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 6
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors: 
 - Lance Pollard
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-14 00:00:00 -05:00
+date: 2010-09-20 00:00:00 -05:00
 default_executable: 
 dependencies: []