acts-as-joinable 0.0.1.7 → 0.0.6

data/README.markdown

@@ -1,82 +1,99 @@
 # ActsAsJoinable
 
-It extends the functionality of `has_and_belongs_to_many`, conventionalizing common use cases.
+Like has_many_polymorphs but easier.  Can handle double polymorphic associations with single table inheritance from the join model.
 
-## Usage
-
-### Install
+## Install
 
     sudo gem install acts-as-joinable
     
-### Add Relationships
+## Usage
+
+### Dry Assocations with Zero Dependencies
 
-Say you have `Post` and `Asset` models.  If each `has_many` of each other `through` some join model, you can write it as such:
+Here's what you would write:
 
-    class Post < ActiveRecord::Base
-      acts_as_joinable_on :assets, :layouts, :tags, :slugs
+    class Content < ActiveRecord::Base
+      joins :assets
+      joins :images
+      joins_one :cover_image, :source => :image
     end
     
-    class Asset < ActiveRecord::Base
-      acts_as_joinable
+    class Page < Content
+      joins :children, :as => :parent, :source => :content
+      joins :parents, :as => :child, :source => :content
     end
     
-That is a replacement for the longer (and non-polymorphic):
-
-    class Post < ActiveRecord::Base
-      has_and_belongs_to_many :assets
+    class Post < Content
+      joins :parents, :as => :child, :source => :page
     end
     
     class Asset < ActiveRecord::Base
-      has_and_belongs_to_many :posts
+      joinable
+    end
+    
+    class Image < Asset
+      
     end
+    
+Here's how you'd use it:
 
-## Why
+    page = Page.create!(:title => "Home Page")
+    post = Post.create!(:title => "My first blog post")
+    image = Image.create!(:src => "http://imgur.com/123123.png")
+    
+    page.children << post
+    post.cover_image = image
+    
+    assert_equal post, page.children.first
+    assert_equal image, post.images.first
+    assert_equal image, post.assets.first
+    
+You can also create a simple group membership system no problem:
 
-Many-to-many relationships end up requiring the same features 99% of the time:
+    class User < ActiveRecord::Base
+      joins :groups, :as => :child, :context => :membership
+    end
 
-1. Join Table that keeps track of `context`
-  - [ActsAsTaggableOn](http://github.com/mbleigh/acts-as-taggable-on/blob/master/lib/generators/acts_as_taggable_on/migration/templates/active_record/migration.rb)
-  - ActsAsAuthorized
-  - [Preferences](http://github.com/pluginaweek/preferences/blob/master/generators/preferences/templates/001_create_preferences.rb)
-  - [FriendlyId](http://github.com/norman/friendly_id/blob/ca9821192c8c3c4e81a938603151645c7cbe1470/generators/friendly_id/templates/create_slugs.rb)
+    class Group < ActiveRecord::Base
+      joins :members, :context => :membership, :source => :user
+      joins_one :admin, :context => :membership, :value => :admin, :source => :user
+      joins :board_of_directors, :context => :membership, :value => :board, :source => :user
+    end
 
-It looks like this:
+    basic_member  = User.create!(:position => "I'm an employee")
+    board_member  = User.create!(:position => "I'm on the board")
+    company       = Group.create!(:name => "A Company")
 
-    create_table :relationships do |t|
-      t.references :parent, :polymorphic => true
-      t.references :child, :polymorphic => true
-      t.string :context
-      t.timestamps
-    end
+    company.members << basic_member
+    company.board_of_directors << board_member
 
-## Alternatives
+    assert_equal 2, company.members.length
+    assert_equal 1, company.board_of_directors
+    
+### What's it doing?
 
-- [ActsAsRelationable](http://github.com/winton/acts_as_relationable)
+First, it has a generic join model.  All join models are the same in the end, so there is no need to create extra tables for each.  Maybe when you get 10,000,000 records you'll need to start creating tables for specific joins, but you don't need that by default.  It increases the complexity of your application unnecessarily which makes it harder to extend and manage.
 
-## Examples
+Instead, this creates a single join model that will solve for most of your cases (if there is a case it doesn't solve for, I'd love to know, it solves all of mine).
 
-If you would like to define accessors that scope the relationship based on the `context` attribute of the `Relationship` model, you can do this:
+Here's the table for the built-in `Relationship` model:
 
-    class Post < ActiveRecord::Base
-      acts_as_joinable_on :assets, :scopes => [:featured, :thumb]
+    create_table :relationships do |t|
+      t.references :parent, :polymorphic => true
+      t.references :child, :polymorphic => true
+      t.string :context
+      t.string :value
+      t.integer :position
+      t.timestamps
     end
     
-    @post                  = Post.new
-    @post.featured_assets  << Asset.first
-    
-If you need more fine-grained control over each relationship scope, you can use a block:
+The features are:
 
-    class Post < ActiveRecord::Base
-      acts_as_joinable_on :tags, :assets
-    end
-    
-    @post                  = Post.new
-    @post.featured_image   = Image.first
-    @post.thumbnails       = Image.all
-    
-The goal of this is to make it so you never have to create migrations or new classes, or rewrite the same code over and over again.  Instead, you can just define `scopes` for cherry-picking the habtm items you'd like.
+1. **Double sided polymorphic associations**.  Which means you can tie any object to any other object.
+2. Built-in relationship directionality, similar to a **Directed Acyclic Graph**.  So you can say the `Post` is `parent` of `Image`, since you usually attach an Image to a Post (not the other way around), so `Image` is `child` of `Post`.  This means you have some sort of built in _hierarchy_.
+3. **Context**.  You can create many-to-many relationships between the same models and call them different things.  This is roughly equivalent to creating STI join models.  This is useful for creating something like organizing `Users` of a `Group` into `Roles`.
+4. **Position**.  You can sort the objects by relationship in primitive ways.
 
-Has 2 key properties on the join model that are pretty common:
+You can always add columns to the relationship table, but the foundation is set.
 
-- context: what the meaning of the join is
-- position: what position the join is in relation to the context
+<cite>copyright @viatropos 2010</cite>

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.1.7"
+  s.version           = "0.0.6"
   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

@@ -25,8 +25,9 @@ module ActsAsJoinable
     def joinable?
       false
     end
-    # the parent in the relationship, so to speak
+    
     def acts_as_joinable_on(*args, &block)
+      args << block
       if joinable?
         write_inheritable_attribute(:acts_as_joinable_config, args)
       else
@@ -34,9 +35,6 @@ module ActsAsJoinable
         class_inheritable_reader(:acts_as_joinable_config)
         
         class_eval do
-          has_many :parent_relationships, :class_name => 'ActsAsJoinable::Relationship', :as => :child, :dependent => :destroy
-          has_many :child_relationships,  :class_name => 'ActsAsJoinable::Relationship', :as => :parent, :dependent => :destroy
-          
           def self.joinable?
             true
           end
@@ -45,19 +43,38 @@ module ActsAsJoinable
         end
       end
     end
-    # the child in the relationship, so to speak
-    def acts_as_joinable(*args, &block)
+    
+    def acts_as_joinable
+      acts_as_joinable_on
+    end
+    
+    def joinable
+      acts_as_joinable_on
+    end
+    
+    def joins_many(*args, &block)
       acts_as_joinable_on(*args, &block)
     end
-
+    
+    def joins(*args, &block)
+      acts_as_joinable_on(*args, &block)
+    end
+    
+    def joins_one(*args, &block)
+      options = args.extract_options!
+      options[:limit] = 1
+      args << options
+      acts_as_joinable_on(*args, &block)
+    end
+    
     def acts_as_relationship
       belongs_to :parent, :polymorphic => true
       belongs_to :child,  :polymorphic => true
 
-      ActsAsJoinable.models.each do |m|
-        belongs_to "parent_#{m}".intern, :foreign_key => 'parent_id', :class_name => m.camelize
-        belongs_to "child_#{m}".intern,  :foreign_key => 'child_id',  :class_name => m.camelize
-      end
+#      ActsAsJoinable.models.each do |m|
+#        belongs_to "parent_#{m}".intern, :foreign_key => 'parent_id', :class_name => m.camelize
+#        belongs_to "child_#{m}".intern,  :foreign_key => 'child_id',  :class_name => m.camelize
+#      end
     end
   end
 end

data/lib/acts_as_joinable/active_record_patch.rb

@@ -0,0 +1,133 @@
+module ActiveRecord
+  module Associations
+    class HasManyThroughAssociation < HasManyAssociation
+      protected
+      # added support for STI with polymorphism
+      def construct_conditions
+        table_name = @reflection.through_reflection.quoted_table_name
+        conditions = construct_quoted_owner_attributes(@reflection.through_reflection).map do |attr, value|
+          if attr =~ /_type$/
+            construct_polymorphic_sql(table_name, attr)
+          else
+            "#{table_name}.#{attr} = #{value}"
+          end
+        end
+        conditions << sql_conditions if sql_conditions
+        
+        "(" + conditions.join(') AND (') + ")"
+      end
+      
+      # Construct attributes for associate pointing to owner.
+      def construct_owner_attributes(reflection)
+        if as = reflection.options[:as]
+          { "#{as}_id" => @owner.id,
+            "#{as}_type" => @owner.class.name.to_s }
+        else
+          { reflection.primary_key_name => @owner.id }
+        end
+      end
+
+      # Construct attributes for :through pointing to owner and associate.
+      def construct_join_attributes(associate)
+        # TODO: revist this to allow it for deletion, supposing dependent option is supported
+        raise ActiveRecord::HasManyThroughCantAssociateThroughHasOneOrManyReflection.new(@owner, @reflection) if [:has_one, :has_many].include?(@reflection.source_reflection.macro)
+        join_attributes = construct_owner_attributes(@reflection.through_reflection).merge(@reflection.source_reflection.primary_key_name => associate.id)
+
+        if @reflection.options[:source_type]
+          join_attributes.merge!(@reflection.source_reflection.options[:foreign_type] => associate.class.name.to_s)
+        end
+        join_attributes
+      end
+
+      # Associate attributes pointing to owner, quoted.
+      def construct_quoted_owner_attributes(reflection)
+        if as = reflection.options[:as]
+          { "#{as}_id" => owner_quoted_id,
+            "#{as}_type" => reflection.klass.quote_value(
+              @owner.class.name.to_s,
+              reflection.klass.columns_hash["#{as}_type"]) }
+        elsif reflection.macro == :belongs_to
+          { reflection.klass.primary_key => @owner[reflection.primary_key_name] }
+        else
+          { reflection.primary_key_name => owner_quoted_id }
+        end
+      end
+      
+      def construct_joins(custom_joins = nil)
+        polymorphic_join = nil
+        if @reflection.source_reflection.macro == :belongs_to
+          reflection_primary_key = @reflection.klass.primary_key
+          source_primary_key     = @reflection.source_reflection.primary_key_name
+          if @reflection.options[:source_type]
+            polymorphic_join = construct_polymorphic_sql(
+              @reflection.through_reflection.quoted_table_name,
+              "#{@reflection.source_reflection.options[:foreign_type]}",
+              @reflection.options[:source_type]
+            )
+            polymorphic_join = "AND (#{polymorphic_join})"
+          end
+        else
+          reflection_primary_key = @reflection.source_reflection.primary_key_name
+          source_primary_key     = @reflection.through_reflection.klass.primary_key
+          if @reflection.source_reflection.options[:as]
+            polymorphic_join = construct_polymorphic_sql(
+              @reflection.quoted_table_name,
+              "#{@reflection.source_reflection.options[:as]}_type",
+              @reflection.through_reflection.klass
+            )
+            polymorphic_join = "AND (#{polymorphic_join})"
+          end
+        end
+        
+        "INNER JOIN %s ON %s.%s = %s.%s %s #{@reflection.options[:joins]} #{custom_joins}" % [
+          @reflection.through_reflection.quoted_table_name,
+          @reflection.quoted_table_name, reflection_primary_key,
+          @reflection.through_reflection.quoted_table_name, source_primary_key,
+          polymorphic_join
+        ]
+      end
+    end
+    
+    class HasManyAssociation < AssociationCollection
+      protected
+      def construct_polymorphic_sql(table_name, attribute, clazz = @owner.class)
+        condition = []
+        clazz = clazz.to_s.constantize unless clazz.is_a?(Class)
+        ancestor_classes = (clazz.ancestors.reverse - clazz.included_modules).uniq + clazz.send(:subclasses)
+        while ancestor = ancestor_classes.pop
+          break if ancestor == clazz.base_class.superclass
+          condition << "#{table_name}.#{attribute} = #{clazz.quote_value(ancestor.name)}"
+        end
+        condition.join(" OR ")
+      end
+      
+      # added support for STI with polymorphism
+      def construct_sql
+        case
+          when @reflection.options[:finder_sql]
+            @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+
+          when @reflection.options[:as]
+            @finder_sql = 
+              "(#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{owner_quoted_id})"
+            polymorphic_conditions = construct_polymorphic_sql(@reflection.quoted_table_name, "#{@reflection.options[:as]}_type")
+            @finder_sql << " AND (#{polymorphic_conditions})"
+            @finder_sql << " AND (#{conditions})" if conditions
+          else
+            @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
+            @finder_sql << " AND (#{conditions})" if conditions
+        end
+
+        if @reflection.options[:counter_sql]
+          @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+        elsif @reflection.options[:finder_sql]
+          # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+          @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+          @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+        else
+          @counter_sql = @finder_sql
+        end
+      end
+    end
+  end
+end

data/lib/acts_as_joinable/core.rb

@@ -8,85 +8,192 @@ module ActsAsJoinable
     end
     
     module ClassMethods
+      
+      # custom parent, self, and child contexts
+      # Group...
+      #   acts_as_joinable_on :groups,
+      #     :as => [:parent, :child],
+      #     :context => :nested_groups,
+      #     :child_classes => %w(pod store)
+      #   acts_as_joinable_on :pods, :as => :parent, :class_name => "Group"
+      #   acts_as_joinable_on :users,
+      #     :as => :parent,
+      #     :context => :membership
+      #     :values => %w(owner developer admin consumer)
+      #   acts_as_joinable_on class|context|custom_alias, class, role, context, context values
+      #   acts_as_joinable_on :members, :class_name => "User", :as => :parent, :context => :memebership
+      #   acts_as_joinable_on :owner, :class_name => "User", :context => :memebership, :value => :owner
+      #   joins_one :owner, :class_name => "User", :context => :memebership, :value => :owner
+      #   joins_many :members, :class_name => "User", :context => :memebership
+      #   joins :user, :with => :role do
+      #     has_many :board_of_directors
+      #     has_one  :owner
+      #   end
+      #   has_many_parent :posts
+      #   has_many_child :assets
+      #   has_many_relationships :users, :through => :memberships
+      #   joins :user, :with => :membership do
+      #     has_many :members
+      #   end
+      # Office
+      #   acts_as_joinable_on :pods, :as => :child
+      #   acts_as_joinable_on :tenants, :as => :parent
+      # User
       def initialize_acts_as_joinable_on_core
-        args    = acts_as_joinable_config.dup
-        options = args.extract_options!
-        if args.empty?
-          args  = ActsAsJoinable.models
-          as    = :child
+        joins     = acts_as_joinable_config.dup
+        block     = joins.pop
+        options   = joins.extract_options!
+        if joins.empty?
+          joins   = ActsAsJoinable.models
+          relationships      = [:child]
         else
-          as    = options[:as] || :parent
+          relationships      = [options[:as] || :parent].flatten.map(&:to_sym)
         end
         
-        class_name = options[:class_name] || nil
+        options[:class_name] ||= options[:source].to_s.camelize if options[:source]
         
-        contexts = options[:contexts] || []
-        contexts = contexts.map(&:to_s).inject({}) {|hash, i| hash[i] = i.empty? ? i : "#{i}_"; hash}
+        association_type = options[:limit] == 1 ? :has_one : :has_many
         
-        sql     = options[:conditions]
+        scope_name = options[:named_scope]
         
-        joins   = args.inject({}) { |hash, i| hash[i.to_s.pluralize] = as; hash }
+        joins.map!(&:to_sym)
         
-        fields  = options[:fields] || []
-        fields  = [fields] unless fields.respond_to?(:flatten)
+        # class name of the model we're joining to self
+        # otherwise it's retrieved from joins.each...
+        class_name  = options[:class_name] || nil
+        # contexts defining the relationship between self and target
+        contexts    = [options[:context] || []].flatten
+        context     = contexts.first
+        # possible values of the context
+        values      = [options[:values] || options[:value] || []].flatten.compact
+        value       = values.first
         
-        has_many :parent_relationships, :class_name => 'ActsAsJoinable::Relationship', :as => :child
-        has_many :child_relationships,  :class_name => 'ActsAsJoinable::Relationship', :as => :parent
+        sql         = options[:conditions]
         
-        joins.each do |type, as|
-          type   = type.to_s
-          singular_type = type.singularize
-          relationship_type = "#{singular_type}_relationships".to_sym
-          select = "#{type}.*, relationships.id AS relationship_id#{fields.empty? ? '' : ', '}" + fields.collect { |f| "relationships.#{f}" }.join(', ')
-
-          role = opposite_for(as).to_sym
-          joined_options = {
-            :select      => select,
-            :conditions  => sql,
-            :through     => relationship_type,
-            :source      => role,
-            :class_name  => class_name ? class_name : type.classify,
-            :source_type => class_name ? class_name : type.classify
-          }
+        nestable    = options[:nestable] || false
+        
+        # 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
+        
+        related_classes = (ancestors.reverse - included_modules + send(:subclasses)).uniq
+        wanted_classes = []
+        while wanted_classes.push(related_classes.pop)
+          break if wanted_classes.last == base_class.superclass
+        end
+        wanted_classes.pop
+        
+        joins.each do |type|
+          singular_type = type.to_s.singularize
+          if association_type == :has_one
+            plural_type   = type.to_s.pluralize
+          else
+            plural_type   = type.to_s
+          end
+          class_name    = options[:class_name] || type.to_s.classify
           
-          relationship_options = {
-            :class_name => 'ActsAsJoinable::Relationship',
-            :as => as
+          join_context = (context || singular_type).to_s
+          
+          options = {
+            :through => :relationships,
+            :class_name => class_name,
+            :source => :child,
+            :source_type => class_name,
+            :conditions => sql
           }
           
-          type = type.to_sym
-
-          # so we don't override
-          unless self.reflect_on_all_associations.detect {|association| association.name.to_s == type.to_s}
-            has_many type,              joined_options
-            has_many relationship_type, relationship_options
+          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
-
-          contexts.each do |context, context_prefix|
-            context_type      = "#{context_prefix}#{type}".to_sym
-            relationship_type = "#{context_prefix}#{singular_type}_relationships".to_sym
-            has_many relationship_type, relationship_options.merge(
-              :conditions => ["#{ActsAsJoinable::Relationship.table_name}.context = ?", context.to_s]
+          
+          # 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
+            
+            if association_type == :has_one
+              relationship_with_context = "#{relationship.to_s}_#{singular_type}_relationship".to_sym
+            else
+              relationship_with_context = "#{relationship.to_s}_#{singular_type}_relationships".to_sym
+            end
+            
+            options = options.merge(
+              :through => relationship_with_context,
+              :source => relationship
             )
-            has_many context_type,  joined_options.merge(
-              :through     => relationship_type,
-              :before_add  => lambda do |parent, child|
-                parent.set_joined(role, type, context, child)
+            
+            join_value = value
+            if join_context
+              unless join_context == class_name.underscore
+                condition_string = "(#{ActsAsJoinable::Relationship.table_name.to_s}.context IN (?))"
+                unless join_value
+#                  join_value = singular_type.to_s
+                end
+                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
               end
-            )
+              
+              through_options = {
+                :class_name => "ActsAsJoinable::Relationship",
+                :conditions => conditions,
+                :as => opposite_for(relationship).to_sym,
+                :dependent => :destroy
+              }
+              
+              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
+              )
+            end
             
-#            define_method context_type do
-#              joins_for(role, type, context)
-#            end
+            options.delete(:after_add) if association_type == :has_one
+            options.delete(:uniq) if association_type == :has_one
             
-#            define_method "add_#{context_type.to_s.singularize}" do |value|
-#              value = [value] unless value.is_a?(Array)
-#              value.each do |item|
-#                set_joined(role, type, context, item)
-#              end
-#            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, &block)
+            
+            accepts_nested_attributes_for plural_type if nestable
+            
+            if association_type == :has_one
+              define_method singular_type do
+                send(plural_type).first
+              end
+              define_method "#{singular_type}=" do |value|
+                send(relationship_with_context).destroy_all
+                send(plural_type) << value
+              end
+              define_method "#{singular_type}_id" do
+                send(singular_type).id rescue nil
+              end
+              define_method "#{singular_type}_id=" do |id|
+                send("#{singular_type}=", class_name.constantize.find(id))
+              end
+            end
           end
-          
         end
       end
       
@@ -100,58 +207,30 @@ module ActsAsJoinable
         role.to_s == "parent" ? "child" : "parent"
       end
       
-    end
-    
-    module InstanceMethods
-      
-      def relationships_for(role, type, context = nil, options = {})        
-        conditions = {
-          "#{role}_type" => type.to_s.classify,
-        }
-        conditions[:context] = context.to_s unless context.blank?
-        options.merge!(:conditions => conditions)
-        
-        self.send("#{type.to_s.singularize}_relationships").all(options)
-      end
-      
-      def relationship_for(role, type, context, value, options = {})
-        relationships_for(role, type, context).detect do |relationship|
-          relationship.send(role).id == value.id
+      def add_association(relationship, plural_type, options, join_context, join_value, &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
+          class_eval <<-EOF
+            def construct_join_attributes(associate)
+              super.merge(#{eval_options.inspect})
+            end
+          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
         end
       end
       
-      def joins_for(role, type, context)
-        relationships_for(role, type, context, :include => opposite_for(role)).map(&role)
-      end
-      
-      def join_for(role, type, context)
-        joins_for(role, type, context).first
-      end
-      
-      def set_joined(role, type, context, value)
-        relationship = relationship_for(role, type, context, value) || ActsAsJoinable::Relationship.new
-        clazz        = get_join_class(type)
-        relationship.send("#{role}=", value.is_a?(clazz) ? value : clazz.find(value))
-        relationship.send("#{opposite_for(role)}=",  self)
-        relationship.context = context.to_s
-        relationship.save
-        self.send("#{context.to_s}_#{type.to_s.pluralize}")
-      end
+    end
+    
+    module InstanceMethods
       
-      private
-        def get_join_class(type)
-          if type.is_a?(String) || type.is_a?(Symbol)
-            type.to_s.singularize.camelize.constantize
-          elsif type.is_a?(Class)
-            type
-          else
-            type.class
-          end
-        end
-        
-        def opposite_for(role)
-          role.to_s == "parent" ? "child" : "parent"
-        end
       
     end
   end

data/test/database.rb

@@ -28,10 +28,17 @@ ActiveRecord::Schema.define(:version => 1) do
     t.timestamps
   end
   
+  create_table :groups, :force => true do |t|
+    t.string :title
+    t.string :type
+    t.timestamps
+  end
+  
   create_table :relationships do |t|
     t.references :parent, :polymorphic => true
     t.references :child, :polymorphic => true
     t.string :context
+    t.string :value
     t.integer :position
     t.timestamps
   end

data/test/lib/asset.rb

@@ -1,4 +1,4 @@
 class Asset < ActiveRecord::Base
-  acts_as_joinable_on :tags
-  acts_as_joinable
+  joins :tags
+  joins :groups, :source => :group, :as => :child
 end

data/test/lib/group.rb

@@ -0,0 +1,7 @@
+class Group < ActiveRecord::Base
+  joins :groups, :as => [:parent, :child]
+  joins :posts
+  joins :photos, :source => :asset, :context => "photos"
+  joins :custom_photos, :source => :asset, :context => "custom"
+  joins :nesteds, :source => :sub_group, :context => :nested
+end

data/test/lib/post.rb

@@ -1,4 +1,3 @@
 class Post < ActiveRecord::Base
-  acts_as_joinable_on :assets, :contexts => [:featured, :thumb]
-  acts_as_joinable_on :tags
+  
 end

data/test/lib/sub_group.rb

@@ -0,0 +1,5 @@
+class SubGroup < Group
+  joins :assets, :images, :pictures, :galleries, :source => :asset
+  joins :parents, :source => :group, :context => :nested, :as => :child
+  joins_one :cover_image, :source => :asset, :through => :relationship, :nestable => true
+end

data/test/lib/tag.rb

@@ -1,3 +1,3 @@
 class Tag < ActiveRecord::Base
-  acts_as_joinable
+  joinable
 end

data/test/test_acts_as_joinable.rb

@@ -4,95 +4,72 @@ class ActsAsJoinableTest < ActiveSupport::TestCase
   
   context "ActsAsJoinable" do
     
-    setup do
-      create_models(1, 2)
-    end
-    
-    should "have 1 of each post, asset, tag to start" do
-      assert_equal 1, Post.count
-      assert_equal 2, Tag.count
-      assert_equal 2, Asset.count
-    end
-    
-    should "have the correct number of Relationship models" do
-      result = [ActsAsJoinable::Relationship.find_all_by_parent_type("Post")]
-      result << ActsAsJoinable::Relationship.find_all_by_parent_type("Asset")
-      result << ActsAsJoinable::Relationship.find_all_by_parent_type("Tag")
-      result.each do |kind|
-        kind.sort {|a, b| b.child_type <=> a.child_type}.each do |relationship|
-          
-        end
-      end
-    end
-    
-    context "correct generated methods" do
+    context "modeling groups" do
       setup do
-        @post  = Post.first
-        @asset = Asset.first
-        @tag   = Tag.first
-      end
-      
-      should "Post should respond_to?(:tags) and respond_to?(:assets)" do
-        assert @post.respond_to?(:tags)
-        assert @post.respond_to?(:assets)
-      end
-      
-      should "Tag should respond_to?(:posts) and respond_to?(:assets)" do
-        assert @tag.respond_to?(:posts)
-        assert @tag.respond_to?(:assets)
-      end
-      
-      should "Post have tags and assets" do
-        assert_equal 2, @post.tags.count
-        assert_equal 2, @post.assets.count
-      end
-      
-      should "Tag have Post and Asset" do
-        assert_equal 1, @tag.posts.count
-        assert_equal 1, @tag.assets.count
-        assert_equal 1, Tag.first.posts.count
-        assert_equal 1, Tag.first.assets.count
+        @grandparent = Group.create!(:title => "Grandparent")
+        @parent = Group.create!(:title => "Parent")
+        @child = Group.create!(:title => "Child")
+        @child_2 = Group.create!(:title => "Child 2")
       end
       
-      should "Asset have Post and Tags" do
-        assert_equal 1, @asset.tags.count
-        assert_equal 1, @asset.posts.count
-        assert_equal 1, Asset.first.tags.count
-        assert_equal 1, Asset.first.posts.count
+      should "allow self referential and sti associations" do
+        @sub_class = SubGroup.create!(:title => "Subgroup!")
+        @grandparent.nesteds << @sub_class
+        @sub_class.reload
+        @grandparent.reload
+        
+        association = ActsAsJoinable::Relationship.first
+        
+        assert @sub_class.valid?
+        assert_equal "SubGroup", association.child_type
+        assert_not_equal "Group", association.child_type
+        assert_equal @grandparent, SubGroup.first.parents.first
       end
       
-      context "custom scopes" do
-      
-        should "have a 'featured_assets' scope on Post" do
-          @post = Post.first
-          assert @post.respond_to?(:featured_assets)
-          @featured = Asset.first
-          @post.featured_assets << @featured
-          #@post.add_featured_asset(@featured)
-          @post = Post.first
-          assert_equal @post.featured_assets.first, @featured
-          assert @post.assets.include?(@featured)
-        end
+      should "have one instead of many" do
+        parent  = SubGroup.create!(:title => "subgroup with has_one :cover_image")
+        child   = Asset.create!
+        another_child = Asset.create!(:title => "Not a cover_image!")
+        
+        parent.cover_image = child
+        parent.galleries << another_child
+        parent.save!
+        parent.reload
+        
+        assert parent.valid?
+        
+        assert_equal child, parent.cover_image
+        assert_equal 1, parent.galleries.length
+        assert_equal 2, parent.assets.length
+        assert_equal 0, parent.images.length
+        assert_equal 0, parent.pictures.length
+        
+        # add another
+        parent.cover_image = another_child
+        parent.save!
+        parent.reload
+
+        assert_equal another_child, parent.cover_image
+        
+        another_child.reload
         
+        assert_equal parent, another_child.groups.first
       end
-    end
-    
-    context "manipulating posts" do
       
-      setup do
-        @post = Post.create!(:title => "testing")
+      should "allow nested attributes" do
+        assert_equal 0, Asset.count
+        
+        parent  = SubGroup.create!(
+          :title => "subgroup with has_one :cover_image",
+          :cover_images_attributes => [{:title => "an image"}]
+        )
+        
+        assert_equal 1, Asset.count
       end
       
-      should "be able to add and remove objects" do
-        @post.assets << Asset.all
-        @post.featured_assets << Asset.all
-        @post = Post.last
+      teardown do
+        destroy_models
       end
-      
-    end
-    
-    teardown do
-      destroy_models
     end
     
   end

data/test/test_helper.rb

@@ -8,10 +8,11 @@ require 'active_record'
 require 'active_record/fixtures'
 require 'shoulda'
 require 'shoulda/active_record'
+require 'logger'
 
 this = File.expand_path(File.dirname(__FILE__))
 
-# ActiveRecord::Base.logger = Logger.new(STDOUT)
+#ActiveRecord::Base.logger = Logger.new(STDOUT)
 
 require File.expand_path(File.join(this, '/../lib/acts-as-joinable'))
 require File.join(this, "database")
@@ -21,6 +22,7 @@ ActsAsJoinable.models = Dir["#{this}/lib/*.rb"].collect { |f| File.basename f, '
 Dir["#{File.dirname(__FILE__)}/../app/models/*"].each { |c| require c if File.extname(c) == ".rb" }
 
 Dir["#{this}/lib/*"].each { |c| require c if File.extname(c) == ".rb" }
+require "#{this}/lib/group"
 
 ActiveRecord::Base.class_eval do
   def self.detonate
@@ -29,8 +31,6 @@ ActiveRecord::Base.class_eval do
 end
 
 ActiveSupport::TestCase.class_eval do
-  
-  
   def create_models(parent = 1, child = 2)
     return unless Post.all.empty?
     parent.times do |i|
@@ -52,5 +52,7 @@ ActiveSupport::TestCase.class_eval do
     Asset.detonate
     Page.detonate
     ActsAsJoinable::Relationship.detonate
+    Group.detonate
+    Asset.detonate
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-joinable
 version: !ruby/object:Gem::Version 
-  hash: 69
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  - 7
-  version: 0.0.1.7
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Lance Pollard
@@ -16,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-02 00:00:00 -07:00
+date: 2010-09-14 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -34,12 +33,15 @@ files:
 - init.rb
 - MIT-LICENSE
 - lib/acts-as-joinable.rb
+- lib/acts_as_joinable/active_record_patch.rb
 - lib/acts_as_joinable/core.rb
 - rails/init.rb
 - test/database.rb
 - test/lib/asset.rb
+- test/lib/group.rb
 - test/lib/page.rb
 - test/lib/post.rb
+- test/lib/sub_group.rb
 - test/lib/tag.rb
 - test/test_acts_as_joinable.rb
 - test/test_helper.rb