acts-as-joinable 0.0.1.5 → 0.0.1.6

data/README.markdown

@@ -51,4 +51,31 @@ It looks like this:
 
 ## Alternatives
 
-- [ActsAsRelationable](http://github.com/winton/acts_as_relationable)
+- [ActsAsRelationable](http://github.com/winton/acts_as_relationable)
+
+## Examples
+
+If you would like to define accessors that scope the relationship based on the `context` attribute of the `Relationship` model, you can do this:
+
+    class Post < ActiveRecord::Base
+      acts_as_joinable_on :assets, :scopes => [:featured, :thumb]
+    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:
+
+    class Post < ActiveRecord::Base
+      acts_as_joinable_on :assets do
+        has_one  :featured_image, where(:...)
+        has_many :thumbnails
+      end
+      acts_as_joinable_on :tags
+    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.

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.5"
+  s.version           = "0.0.1.6"
   s.summary           = "ActsAsJoinable: DRYing up Many-to-Many Relationships in ActiveRecord"
   s.homepage          = "http://github.com/viatropos/cockpit"
   s.email             = "lancejpollard@gmail.com"

data/lib/acts-as-joinable.rb

@@ -13,160 +13,47 @@ module ActsAsJoinable
   end
   
   module ClassMethods
+    
+    def joinable?
+      false
+    end
     # the parent in the relationship, so to speak
     def acts_as_joinable_on(*args, &block)
-      if args.empty? # Relationship model
-        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
+      if joinable?
+        write_inheritable_attribute(:acts_as_joinable_config, args)
       else
-        options = args.extract_options!
-        sql     = options[:conditions]
-        table   = options[:table]
-        fields  = options[:fields] || []
-        fields  = [ fields ] unless fields.respond_to?(:flatten)
+        write_inheritable_attribute(:acts_as_joinable_config, args)
+        class_inheritable_reader(:acts_as_joinable_config)
         
-        has_many :parent_relationships, :class_name => 'ActsAsJoinable::Relationship', :as => :child
-        has_many :child_relationships,  :class_name => 'ActsAsJoinable::Relationship', :as => :parent
-        
-        args.each do |type|
-          type   = type.to_s
-          table  = table || type
-          select = "#{table}.*, relationships.id AS relationship_id#{fields.empty? ? '' : ', '}" + fields.collect { |f| "relationships.#{f}" }.join(', ')
-          opts = {
-            :select      => select,
-            :conditions  => sql,
-            :through     => :parent_relationships,
-            :source      => :parent,
-            :class_name  => type.classify,
-            :source_type => table.classify
-          }
-          
-          has_many "parent_#{type}", opts do
-            fields.each do |field|
-              define_method field.to_s.pluralize do |*args|
-                value = args[0] || 1
-                scoped :conditions => [ "relationships.#{field} = ?", value ]
-              end
-            end
-          end
-          
-          opts = {
-            :select      => select,
-            :conditions  => sql,
-            :through     => :child_relationships,
-            :source      => :child,
-            :class_name  => type.classify,
-            :source_type => table.classify
-          }
+        class_eval do
+          has_many :parent_relationships, :class_name => 'ActsAsJoinable::Relationship', :as => :child
+          has_many :child_relationships,  :class_name => 'ActsAsJoinable::Relationship', :as => :parent
           
-          has_many "child_#{type}", opts do
-            fields.each do |field|
-              define_method field.to_s.pluralize do |*args|
-                value = args[0] || 1
-                scoped :conditions => [ "relationships.#{field} = ?", value ]
-              end
-            end
+          def self.joinable?
+            true
           end
           
-          self.class_eval do
-            # Records reader
-            define_method type do |*args|
-              if (read_attribute(:type) || self.class.to_s) < (args.empty? ? type.classify : args[0].to_s)
-                eval "self.child_#{type}"
-              else
-                eval "self.parent_#{type}"
-              end
-            end
-          end
-          
-          fields.each do |field|
-            # Relationship field writer
-            self.class_eval do
-              define_method field.to_s + '=' do |value|
-                modified = read_attribute(:modified_relationship_fields) || []
-                modified << field
-                write_attribute :modified_relationship_fields, modified.uniq
-                write_attribute field, value
-              end
-            end
-          end
-        end
-        unless included_modules.include?(InstanceMethods)
-          extend ClassMethods
-          include InstanceMethods
-          before_save :save_relationship_fields
+          include ActsAsJoinable::Core
         end
       end
     end
-    
     # the child in the relationship, so to speak
     def acts_as_joinable(*args, &block)
       acts_as_joinable_on(*args, &block)
     end
-  end
-  
-  module InstanceMethods
-    # Before save
-    def save_relationship_fields
-      return unless read_attribute(:relationship_id) && read_attribute(:modified_relationship_fields)
-      r = Relationship.find self.relationship_id
-      read_attribute(:modified_relationship_fields).each do |field|
-        r[field] = self[field]
-      end
-      r.save
-      write_attribute :modified_relationship_fields, nil
-    end
-    
-    def get_joining(type, context)
-      get_joinings(type, context).first
-    end
-    
-    def get_joinings(type, context)
-      self.joinings.select do |joining|
-        joining.context == context.to_s
-      end
-    end
-    
-    def get_joined(type, context)
-      get_joineds(type, context).first
-    end
-    
-    def get_joineds(type, context)
-      return [] unless self.joineds and !self.joineds.empty?
-      
-      get_joinings(context).collect do |joining|
-        joining.joined
+
+    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
     end
-    
-    def set_joined(type, context, value)
-      joining = get_joining(context) || Joining.new
-      clazz   = get_join_class(type)
-      joining.joined = value.is_a?(clazz) ? value : clazz.find(value)
-      joining.joining = self
-      joining.context = context.to_s
-      joining.save
-      self.send("#{context.to_s}_#{type.to_s}")
-    end
-    
-    private
-      def get_join_class(type)
-        if type.is_a?(String) || type.is_a?(Symbol)
-          type.to_s.camelize.constantize
-        elsif type.is_a?(Class)
-          type
-        else
-          type.class
-        end
-      end
   end
 end
 
 ActiveRecord::Base.send(:include, ActsAsJoinable) if defined?(ActiveRecord::Base)
 
-Dir["#{File.dirname(__FILE__)}/../app/models/*"].each { |c| require c if File.extname(c) == ".rb" }
+Dir["#{File.dirname(__FILE__)}/acts_as_joinable/*"].each { |c| require c if File.extname(c) == ".rb" }

data/lib/acts_as_joinable/core.rb

@@ -0,0 +1,153 @@
+module ActsAsJoinable
+  module Core
+    def self.included(base)
+      base.send :include, ActsAsJoinable::Core::InstanceMethods
+      base.extend         ActsAsJoinable::Core::ClassMethods
+      
+      base.initialize_acts_as_joinable_on_core
+    end
+    
+    module ClassMethods
+      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
+        else
+          as    = options[:as] || :parent
+        end
+        
+        contexts = options[:contexts] || []
+        contexts = contexts.map(&:to_s).inject({}) {|hash, i| hash[i] = i.empty? ? i : "#{i}_"; hash}
+        
+        sql     = options[:conditions]
+        
+        joins   = args.inject({}) { |hash, i| hash[i.to_s.pluralize] = as; hash }
+        
+        fields  = options[:fields] || []
+        fields  = [fields] unless fields.respond_to?(:flatten)
+        
+        has_many :parent_relationships, :class_name => 'ActsAsJoinable::Relationship', :as => :child
+        has_many :child_relationships,  :class_name => 'ActsAsJoinable::Relationship', :as => :parent
+        
+        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  => type.classify,
+            :source_type => type.classify
+          }
+          
+          relationship_options = {
+            :class_name => 'ActsAsJoinable::Relationship',
+            :as => as
+          }
+          
+          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
+          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]
+            )
+           
+            has_many context_type,  joined_options.merge(
+              :through     => relationship_type,
+              :before_add  => lambda do |parent, child|
+                parent.set_joined(role, type, context, child)
+              end
+            )
+            
+#            define_method context_type do
+#              joins_for(role, type, context)
+#            end
+            
+#            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
+          end
+          
+        end
+      end
+      
+      def acts_as_joinable_on(*args)
+        super(*args)
+        initialize_acts_as_joinable_on_core
+      end
+      
+      private
+      def opposite_for(role)
+        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
+        end
+      end
+      
+      def joins_for(role, type, context)
+        relationships_for(role, type, context, :include => opposite_for(role)).map(&role)
+      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
+      
+      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
+end

data/test/{lib/_database.rb → database.rb}

@@ -23,6 +23,11 @@ ActiveRecord::Schema.define(:version => 1) do
     t.timestamps
   end
   
+  create_table :pages, :force => true do |t|
+    t.string :title
+    t.timestamps
+  end
+  
   create_table :relationships do |t|
     t.references :parent, :polymorphic => true
     t.references :child, :polymorphic => true

data/test/lib/asset.rb

@@ -1,3 +1,4 @@
 class Asset < ActiveRecord::Base
+  acts_as_joinable_on :tags
   acts_as_joinable
 end

data/test/lib/page.rb

@@ -0,0 +1,6 @@
+class Page < ActiveRecord::Base
+  acts_as_joinable_on :assets do
+    has_many :featured_images
+  end
+  acts_as_joinable_on :tags
+end

data/test/lib/post.rb

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

data/test/test_acts_as_joinable.rb

@@ -14,24 +14,85 @@ class ActsAsJoinableTest < ActiveSupport::TestCase
       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
       setup do
-        @post = Post.first
+        @post  = Post.first
         @asset = Asset.first
-        @tag = Tag.first
+        @tag   = Tag.first
       end
       
       should "Post should respond_to?(:tags) and respond_to?(:assets)" do
-        puts @post.tags.inspect + " !!"
         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
+      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
+      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
+        
+      end
+    end
+    
+    context "manipulating posts" do
+      
+      setup do
+        @post = Post.create!(:title => "testing")
+      end
+      
+      should "be able to add and remove objects" do
+        @post.assets << Asset.all
+        @post.featured_assets << Asset.all
+        @post = Post.last
+      end
+      
     end
     
     teardown do
-      Post.detonate
-      Tag.detonate
-      Asset.detonate
+      destroy_models
     end
     
   end

data/test/test_helper.rb

@@ -11,9 +11,14 @@ require 'shoulda/active_record'
 
 this = File.expand_path(File.dirname(__FILE__))
 
+# ActiveRecord::Base.logger = Logger.new(STDOUT)
+
 require File.expand_path(File.join(this, '/../lib/acts-as-joinable'))
+require File.join(this, "database")
+
+ActsAsJoinable.models = Dir["#{this}/lib/*.rb"].collect { |f| File.basename f, '.rb' }
 
-ActsAsJoinable.models = Dir["#{this}/../app/models/*.rb"].collect { |f| File.basename f, '.rb' }
+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" }
 
@@ -25,14 +30,27 @@ end
 
 ActiveSupport::TestCase.class_eval do
   
+  
   def create_models(parent = 1, child = 2)
+    return unless Post.all.empty?
     parent.times do |i|
       post = Post.create!(:title => "title-#{i.to_s}")
       child.times do |j|
         position = (i + 1) * (j + 1)
         asset = Asset.create!(:title => "asset-title-#{position.to_s}")
         tag   = Tag.create!(:name => "tag-name-#{position.to_s}")
+        asset.tags << tag
+        post.tags << tag
+        post.assets << asset
       end
     end
   end
-end
+  
+  def destroy_models
+    Post.detonate
+    Tag.detonate
+    Asset.detonate
+    Page.detonate
+    ActsAsJoinable::Relationship.detonate
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: acts-as-joinable
 version: !ruby/object:Gem::Version 
-  hash: 65
+  hash: 71
   prerelease: false
   segments: 
   - 0
   - 0
   - 1
-  - 5
-  version: 0.0.1.5
+  - 6
+  version: 0.0.1.6
 platform: ruby
 authors: 
 - Lance Pollard
@@ -34,9 +34,11 @@ files:
 - init.rb
 - MIT-LICENSE
 - lib/acts-as-joinable.rb
+- lib/acts_as_joinable/core.rb
 - rails/init.rb
-- test/lib/_database.rb
+- test/database.rb
 - test/lib/asset.rb
+- test/lib/page.rb
 - test/lib/post.rb
 - test/lib/tag.rb
 - test/test_acts_as_joinable.rb