Groupify v1.0.0: Better STI/polymorphism and various fixes

README.md

@@ -74,7 +74,7 @@ Set up your member models:
 ```ruby
 class User
   include Mongoid::Document
-  
+
   groupify :group_member
   groupify :named_group_member
 end
@@ -131,10 +131,71 @@ Example:
 class Organization < Group
   has_members :offices, :equipment
 end
+
+class InternationalOrganization < Organization
+  has_member :offices, class_name: 'CustomOfficeClass'
+  has_member :equipment, class_name: 'CustomEquipmentClass'
+end
 ```
 
 Mongoid works the same way by creating Mongoid relations.
 
+With polymorphic groups, the `default_members` option specifies the association
+on the group to which members should be added. When specifying individual `has_member`
+options, `default_members: true` indicates the association is the one to add new
+members to. (If the `default_members` is not specified and the `members` association
+does not exist, adding users to subclasses of a group can cause a
+`ActiveRecord::AssociationTypeMismatch` exception.)
+
+Example:
+
+```ruby
+class GroupBase < ActiveRecord::Base
+  self.table_name = "groups"
+  self.abstract_class = true
+end
+
+class Organization < GroupBase
+  acts_as_group
+  has_member :users, class_name: 'CustomUserClass', default_members: true
+end
+
+org = Organization.create!
+user = CustomUserClass.create!
+
+# adds the user to the `ord.users` association
+org.add user, as: 'admin'
+```
+
+##### Group Associations on Member (ActiveRecord only)
+
+Your member class can be configured to create associations for each expected group type.
+For example, let's say that your member class will have multiple types of organizations as groups.
+The following configuration adds `organizations` and `international_organizations` associations
+on the member model:
+
+```ruby
+class Group < ActiveRecord::Base
+  groupify :group, members: [:users, :assignments], default_members: :users
+end
+
+class Organization < Group
+  has_members :offices, :equipment
+end
+
+class InternationalOrganization < Organization
+end
+
+class Member < ActiveRecord::Base
+  groupify :group_member
+
+  has_group :organizations, class_name: 'Organization'
+  has_group :international_organizations, class_name: 'InternationalOrganization'
+end
+```
+
+Mongoid does not support the `has_group` helper method.
+
 ## Usage
 
 ### Create groups and add members

lib/groupify.rb

@@ -14,6 +14,10 @@ def self.configure
   def self.group_membership_klass
     group_membership_class_name.constantize
   end
+
+  def self.quoted_column_name_for(model_class, column_name)
+    "#{model_class.quoted_table_name}.#{::ActiveRecord::Base.connection.quote_column_name(column_name)}"
+  end
 end
 
 require 'groupify/railtie' if defined?(Rails)

lib/groupify/adapter/active_record/association_extensions.rb

@@ -0,0 +1,100 @@
+module Groupify
+  module ActiveRecord
+    module AssociationExtensions
+      extend ActiveSupport::Concern
+
+      def as(membership_type)
+        return self unless membership_type
+        merge(Groupify.group_membership_klass.as(membership_type))
+      end
+
+      # Defined to create alias methods before
+      # the association is extended with this module
+      def <<(*)
+        super
+      end
+
+      def add_without_exception(*children)
+        add_children_to_parent(children.flatten, false)
+      end
+
+      def add_with_exception(*children)
+        add_children_to_parent(children.flatten, true)
+      end
+
+      alias_method :add_as_usual, :<<
+      alias_method :<<, :add_without_exception
+      alias_method :add, :add_with_exception
+
+      def delete(*records)
+        remove_children_from_parent(records.flatten, :delete){ |records| super(*records) }
+      end
+
+      def destroy(*records)
+        remove_children_from_parent(records.flatten, :destroy){ |records| super(*records) }
+      end
+
+    protected
+
+      def remove_children_from_parent(records, destruction_type, &fallback)
+        membership_type = records.extract_options![:as]
+
+        if membership_type
+          find_for_destruction(membership_type, records).__send__(:"#{destruction_type}_all")
+        else
+          fallback.call(records)
+        end
+
+        records.each{|record| record.__send__(:clear_association_cache)}
+      end
+
+      def add_children_to_parent(children, exception_on_invalidation)
+        membership_type = children.extract_options![:as]
+
+        return self if children.none?
+
+        parent = proxy_association.owner
+        parent.__send__(:clear_association_cache)
+
+        to_add_directly = []
+        to_add_with_membership_type = []
+
+        # first prepare changes
+        children.each do |child|
+          # add to collection without membership type
+          to_add_directly << child unless self.include?(child)
+          # add a second entry for the given membership type
+          if membership_type
+            membership = find_memberships_for(child, membership_type).first_or_initialize
+            to_add_with_membership_type << membership unless membership.persisted?
+          end
+          parent.__send__(:clear_association_cache)
+        end
+
+        # then validate changes
+        list_to_validate = to_add_directly + to_add_with_membership_type
+
+        list_to_validate.each do |child|
+          next if child.valid?
+
+          if exception_on_invalidation
+            raise RecordInvalid.new(child)
+          else
+            return false
+          end
+        end
+
+        # then persist changes
+        add_as_usual(to_add_directly)
+
+        to_add_with_membership_type.each do |membership|
+          membership_parent = membership.__send__(association_parent_type)
+          membership_parent.__send__(:"group_memberships_as_#{association_parent_type}") << membership
+          membership_parent.__send__(:clear_association_cache)
+        end
+
+        self
+      end
+    end
+  end
+end

lib/groupify/adapter/active_record/group.rb

@@ -1,3 +1,5 @@
+require 'groupify/adapter/active_record/member_association_extensions'
+
 module Groupify
   module ActiveRecord
 
@@ -15,32 +17,25 @@ module Group
       included do
         @default_member_class = nil
         @member_klasses ||= Set.new
-        has_many :group_memberships_as_group,
-                 dependent: :destroy,
-                 as: :group,
-                 class_name: Groupify.group_membership_class_name
 
+        has_many :group_memberships_as_group,
+          dependent: :destroy,
+          as: :group,
+          class_name: Groupify.group_membership_class_name
       end
 
       def member_classes
         self.class.member_classes
       end
 
-      def add(*args)
-        opts = args.extract_options!
-        membership_type = opts[:as]
-        members = args.flatten
-        return unless members.present?
+      def add(*members)
+        opts = members.extract_options!
 
-        __send__(:clear_association_cache)
-
-        members.each do |member|
-          member.groups << self unless member.groups.include?(self)
-          if membership_type
-            member.group_memberships_as_member.where(group_id: id, group_type: self.class.model_name.to_s, membership_type: membership_type).first_or_create!
-          end
-          member.__send__(:clear_association_cache)
+        members.flatten.each do |member|
+          member.groups.add(self, opts)
         end
+
+        self
       end
 
       # Merge a source group into this group.
@@ -50,7 +45,8 @@ def merge!(source)
 
       module ClassMethods
         def with_member(member)
-          member.groups
+          memberships_merge(member.group_memberships_as_member).
+          extending(Groupify::ActiveRecord::GroupAssociationExtensions)
         end
 
         def default_member_class
@@ -69,73 +65,52 @@ def member_classes
         # Define which classes are members of this group
         def has_members(*names)
           Array.wrap(names.flatten).each do |name|
+            has_member name
+          end
+        end
+
+        def has_member(name, options = {})
+          klass_name = options[:class_name]
+
+          if klass_name.nil?
             klass = name.to_s.classify.constantize
-            register(klass)
+            association_name = name.is_a?(Symbol) ? name : klass.model_name.plural.to_sym
+          else
+            klass = klass_name.to_s.classify.constantize
+            association_name = name.to_sym
           end
+
+          register(klass, association_name)
         end
 
         # Merge two groups. The members of the source become members of the destination, and the source is destroyed.
         def merge!(source_group, destination_group)
           # Ensure that all the members of the source can be members of the destination
           invalid_member_classes = (source_group.member_classes - destination_group.member_classes)
           invalid_member_classes.each do |klass|
-            if klass.joins(:group_memberships_as_member).merge(Groupify.group_membership_klass.where(group_id: source_group)).count > 0
+            if klass.memberships_merge(source_group.group_memberships_as_group).count > 0
               raise ArgumentError.new("#{source_group.class} has members that cannot belong to #{destination_group.class}")
             end
           end
 
           source_group.transaction do
-            source_group.group_memberships_as_group.update_all(:group_id => destination_group.id)
+            source_group.group_memberships_as_group.update_all(group_id: destination_group.id, group_type: destination_group.class.base_class.name)
             source_group.destroy
           end
         end
 
-        protected
+      protected
 
-        def register(member_klass)
+        def register(member_klass, association_name = nil)
           (@member_klasses ||= Set.new) << member_klass
 
-          associate_member_class(member_klass)
+          associate_member_class(member_klass, association_name)
 
           member_klass
         end
 
-        module MemberAssociationExtensions
-          def as(membership_type)
-            merge(Groupify.group_membership_klass.as(membership_type))
-          end
-
-          def delete(*args)
-            opts = args.extract_options!
-            members = args
-
-            if opts[:as]
-              proxy_association.owner.group_memberships_as_group.
-                  where(member_id: members.map(&:id), member_type: proxy_association.reflection.options[:source_type]).
-                  as(opts[:as]).
-                  delete_all
-            else
-              super(*members)
-            end
-          end
-
-          def destroy(*args)
-            opts = args.extract_options!
-            members = args
-
-            if opts[:as]
-              proxy_association.owner.group_memberships_as_group.
-                  where(member_id: members.map(&:id), member_type: proxy_association.reflection.options[:source_type]).
-                  as(opts[:as]).
-                  destroy_all
-            else
-              super(*members)
-            end
-          end
-        end
-
-        def associate_member_class(member_klass)
-          define_member_association(member_klass)
+        def associate_member_class(member_klass, association_name = nil)
+          define_member_association(member_klass, association_name)
 
           if member_klass == default_member_class
             define_member_association(member_klass, :members)
@@ -147,11 +122,18 @@ def define_member_association(member_klass, association_name = nil)
           source_type = member_klass.base_class
 
           has_many association_name,
-                   ->{ distinct },
-                   through: :group_memberships_as_group,
-                   source: :member,
-                   source_type: source_type.to_s,
-                   extend: MemberAssociationExtensions
+            ->{ distinct },
+            through: :group_memberships_as_group,
+            source: :member,
+            source_type: source_type.to_s,
+            extend: Groupify::ActiveRecord::MemberAssociationExtensions
+        end
+
+        def memberships_merge(merge_criteria, &group_membership_filter)
+          query = joins(:group_memberships_as_group)
+          query = query.merge(merge_criteria) if merge_criteria
+          query = query.merge(Groupify.group_membership_klass.instance_eval(&group_membership_filter)) if block_given?
+          query
         end
       end
     end

lib/groupify/adapter/active_record/group_association_extensions.rb

@@ -0,0 +1,26 @@
+require 'groupify/adapter/active_record/association_extensions'
+
+module Groupify
+  module ActiveRecord
+    module GroupAssociationExtensions
+      include AssociationExtensions
+
+    protected
+
+      def association_parent_type
+        :member
+      end
+
+      def find_memberships_for(group, membership_type)
+        proxy_association.owner.group_memberships_as_member.
+          merge(group.group_memberships_as_group).
+          as(membership_type)
+      end
+
+      def find_for_destruction(membership_type, groups)
+        proxy_association.owner.group_memberships_as_member.
+          for_groups(groups).as(membership_type)
+      end
+    end
+  end
+end