acts-as-joinable 0.1.1 → 0.1.3

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.1.1"
+  s.version           = "0.1.3"
   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/core.rb

@@ -42,35 +42,35 @@ module ActsAsJoinable
       def initialize_acts_as_joinable_on_core
         joins       = acts_as_joinable_config.dup
         block       = joins.pop
-        options     = joins.extract_options!
+        opts        = joins.extract_options!
         if joins.empty?
           joins     = ActsAsJoinable.models
           relationships      = [:child]
         else
-          relationships      = [options[:as] || :parent].flatten.map(&:to_sym)
+          relationships      = [opts[:as] || :parent].flatten.map(&:to_sym)
         end
         
-        options[:class_name] ||= options[:source].to_s.camelize if options[:source]
+        opts[:class_name] ||= opts[:source].to_s.camelize if opts[:source]
         
-        association_type = options[:limit] == 1 ? :has_one : :has_many
+        association_type = opts[:limit] == 1 ? :has_one : :has_many
         
-        scope_name  = options[:named_scope]
+        scope_name  = opts[:named_scope]
         
         joins.map!(&:to_sym)
         
         # class name of the model we're joining to self
         # otherwise it's retrieved from joins.each...
-        class_name  = options[:class_name] || nil
+        class_name  = opts[:class_name] || nil
         # contexts defining the relationship between self and target
-        contexts    = [options[:context] || []].flatten
+        contexts    = [opts[:context] || []].flatten
         context     = contexts.first
         # possible values of the context
-        values      = [options[:values] || options[:value] || []].flatten.compact
+        values      = [opts[:values] || opts[:value] || []].flatten.compact
         value       = values.first
         
-        sql         = options[:conditions]
+        sql         = opts[:conditions]
         
-        nestable    = options[:nestable] || false
+        nestable    = opts[:nestable] || false
         
         # parent, child, or contexts (both) for custom helper getters/setters
         
@@ -89,75 +89,72 @@ module ActsAsJoinable
         joins.each do |type|
           singular_type = type.to_s.singularize
           if association_type == :has_one
-            plural_type   = type.to_s.pluralize
+            plural_type   = type.to_s.pluralize.to_sym
           else
-            plural_type   = type.to_s
+            plural_type   = type.to_s.to_sym
           end
-          class_name    = options[:class_name] || type.to_s.classify
+          class_name    = opts[:class_name] || type.to_s.classify
           
           join_context = (context || singular_type).to_s
           
           options = {
-            :through => :relationships,
-            :class_name => class_name,
-            :source => :child,
-            :source_type => class_name,
-            :conditions => sql
+            :through              => :relationships,
+            :class_name           => class_name,
+            :source               => :child,
+            :source_type          => class_name,
+            :conditions           => sql
           }
           
           # relationships == [:parent, :child]
           relationships.each do |relationship|
-            relationship = opposite_for(relationship)
-            singular_relationship = "#{relationship.to_s}_relationship".to_sym
-            plural_relationship   = "#{relationship.to_s}_relationships".to_sym
-            plural_relationship = "#{relationship.to_s}_relationships".to_sym
+            # Post.joins :tags, :as => :parent
+            # through_relationship = child_tag_relationships
+            # relationship_table   = `relationships`
+            relationship          = opposite_for(relationship)
+            through_relationship  = "#{relationship.to_s}_#{singular_type}_relationships".to_sym
+            relationship_table    = ActsAsJoinable::Relationship.quoted_table_name
             
-            if association_type == :has_one
-              relationship_with_context = "#{relationship.to_s}_#{singular_type}_relationship".to_sym
+            options.merge!(:through => through_relationship, :source => relationship, :uniq => true)
+            
+            join_value            = value
+            
+            # conditions for the join model
+            condition_string      = ""
+            #if join_context == class_name.underscore
+              
+#            condition_string      << "(#{relationship_table}.#{relationship}_type IN (?))"
+            if join_context == class_name.underscore
+              #conditions            = [condition_string, [class_name]]
             else
-              relationship_with_context = "#{relationship.to_s}_#{singular_type}_relationships".to_sym
+              condition_string      << "(#{relationship_table}.context IN (?))"
+              condition_string      << " AND (#{relationship_table}.value = ?)" if join_value
+              join_contexts         = [join_context]#[join_context, class_name.underscore].uniq
+              conditions            = [condition_string, join_contexts]
+              conditions            << join_value.to_s if join_value
             end
             
-            options = options.merge(
-              :through => relationship_with_context,
-              :source => relationship
-            )
+            through_options = {
+              :class_name => "ActsAsJoinable::Relationship",
+              :conditions => conditions,
+              :as => opposite_for(relationship).to_sym
+            }
             
-            join_value = value
-            if join_context
-              condition_string = "(#{ActsAsJoinable::Relationship.table_name.to_s}.context IN (?))"
-              condition_string << " AND (#{ActsAsJoinable::Relationship.table_name.to_s}.value = ?)" if join_value
-              join_contexts = [join_context, class_name.underscore]
-              conditions = [condition_string, join_contexts]
-              conditions << join_value.to_s if join_value
-              
-              through_options = {
-                :class_name => "ActsAsJoinable::Relationship",
-                :conditions => conditions,
-                :as => opposite_for(relationship).to_sym
-              }
-              
-              through_options[:uniq] = true unless association_type == :has_one
-              
-              # has_many :member_relationships
-              # conditions: context == x, value == y 
-              send(:has_many, relationship_with_context, through_options)
-              
-              options = options.merge(
-                :through => relationship_with_context,
-                :source => relationship,
-                :uniq => true
-              )
+            if association_type == :has_one
+              options.delete(:after_add) 
+              options.delete(:uniq)
+            else
+              through_options[:uniq] = true
             end
             
-            options.delete(:after_add) if association_type == :has_one
-            options.delete(:uniq) if association_type == :has_one
+            unless has_association?(through_relationship)
+              has_many through_relationship, through_options
+            end
             
-            method_scope = association_type == :has_one ? :protected : :public
-            #send(method_scope)
-            # has_many :child_users, :through => :child_relationships
             add_association(relationship.to_s, plural_type, options, join_context, join_value, nestable, &block)
-            add_has_one(singular_type, plural_type, relationship_with_context, class_name) if association_type == :has_one
+            
+            if association_type == :has_one
+              add_has_one(singular_type, plural_type, through_relationship, class_name)
+            end
           end
         end
       end
@@ -172,12 +169,16 @@ module ActsAsJoinable
         role.to_s == "parent" ? "child" : "parent"
       end
       
+      def has_association?(name)
+        self.reflect_on_all_associations.map(&:name).include?(name.to_sym)
+      end
+      
       def add_has_one(singular_type, plural_type, relationship_with_context, class_name)
         define_method singular_type do
           send(plural_type).last
         end
         define_method "#{singular_type}=" do |value|
-#          send(relationship_with_context).delete_all
+          send(relationship_with_context).delete_all
           send(plural_type) << value
         end
         define_method "#{singular_type}_id" do
@@ -192,15 +193,24 @@ module ActsAsJoinable
         eval_options = {:context => join_context}
         eval_options[:value] = join_value unless join_value.blank?
         # has_many :users, :through => :child_relationships
+        plural_relationship = "#{relationship}_#{plural_type}".to_sym
+        unless has_association?(plural_relationship)
+          send(:has_many, plural_relationship, options) do
+            class_eval <<-EOF
+              def construct_join_attributes(associate)
+                super.merge(#{eval_options.inspect})
+              end
+            EOF
+          end
+        end
         
-        unless self.reflect_on_all_associations.map(&:name).include?(plural_type.to_sym)
+        unless has_association?(plural_type)
           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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-joinable
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Lance Pollard