groupify 0.6.0.rc1 → 0.6.0.rc2

data/lib/groupify/adapter/active_record/group.rb

@@ -0,0 +1,159 @@
+module Groupify
+  module ActiveRecord
+
+    # Usage:
+    #    class Group < ActiveRecord::Base
+    #        acts_as_group, :members => [:users]
+    #        ...
+    #    end
+    #
+    #   group.add(member)
+    #
+    module Group
+      extend ActiveSupport::Concern
+
+      included do
+        @default_member_class = nil
+        @member_klasses ||= Set.new
+        has_many :group_memberships, :dependent => :destroy
+      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?
+
+        clear_association_cache
+
+        members.each do |member|
+          member.group_memberships.where(group_id: self.id).first_or_create!
+          if membership_type
+            member.group_memberships.where(group_id: self.id, membership_type: membership_type).first_or_create!
+          end
+          member.clear_association_cache
+        end
+      end
+
+      # Merge a source group into this group.
+      def merge!(source)
+        self.class.merge!(source, self)
+      end
+
+      module ClassMethods
+        def with_member(member)
+          #joins(:group_memberships).where(:group_memberships => {:member_id => member.id, :member_type => member.class.to_s})
+          member.groups
+        end
+
+        def default_member_class
+          @default_member_class ||= (User rescue false)
+        end
+
+        def default_member_class=(klass)
+          @default_member_class = klass
+        end
+
+        # Returns the member classes defined for this class, as well as for the super classes
+        def member_classes
+          (@member_klasses ||= Set.new).merge(superclass.method_defined?(:member_classes) ? superclass.member_classes : [])
+        end
+
+        # Define which classes are members of this group
+        def has_members(name)
+          klass = name.to_s.classify.constantize
+          register(klass)
+        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).where(:group_memberships => {:group_id => source_group.id}).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.update_all(:group_id => destination_group.id)
+            source_group.destroy
+          end
+        end
+
+        protected
+
+        def register(member_klass)
+          (@member_klasses ||= Set.new) << member_klass
+
+          associate_member_class(member_klass)
+
+          member_klass
+        end
+
+        module MemberAssociationExtensions
+          def as(membership_type)
+            where(group_memberships: {membership_type: membership_type})
+          end
+
+          def delete(*args)
+            opts = args.extract_options!
+            members = args
+
+            if opts[:as]
+              proxy_association.owner.group_memberships.
+                  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.
+                  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)
+          association_name = member_klass.name.to_s.pluralize.underscore.to_sym
+          source_type = member_klass.base_class
+
+          has_many association_name, through: :group_memberships, source: :member, source_type: source_type, extend: MemberAssociationExtensions
+          override_member_accessor(association_name)
+
+          if member_klass == default_member_class
+            has_many :members, through: :group_memberships, source: :member, source_type: source_type, extend: MemberAssociationExtensions
+            override_member_accessor(:members)
+          end
+        end
+
+        def override_member_accessor(association_name)
+          define_method(association_name) do |*args|
+            opts = args.extract_options!
+            membership_type = opts[:as]
+            if membership_type.present?
+              super().as(membership_type)
+            else
+              super()
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groupify/adapter/active_record/group_member.rb

@@ -0,0 +1,137 @@
+module Groupify
+  module ActiveRecord
+
+    # Usage:
+    #    class User < ActiveRecord::Base
+    #        acts_as_group_member
+    #        ...
+    #    end
+    #
+    #    user.groups << group
+    #
+    module GroupMember
+      extend ActiveSupport::Concern
+
+      included do
+        unless respond_to?(:group_memberships)
+          has_many :group_memberships, :as => :member, :autosave => true, :dependent => :destroy
+        end
+
+        has_many :groups, :through => :group_memberships, :class_name => @group_class_name do
+          def as(membership_type)
+            return self unless membership_type
+            where(group_memberships: {membership_type: membership_type})
+          end
+
+          def delete(*args)
+            opts = args.extract_options!
+            groups = args.flatten
+
+            if opts[:as]
+              proxy_association.owner.group_memberships.where(group_id: groups.map(&:id)).as(opts[:as]).delete_all
+            else
+              super(*groups)
+            end
+          end
+
+          def destroy(*args)
+            opts = args.extract_options!
+            groups = args.flatten
+
+            if opts[:as]
+              proxy_association.owner.group_memberships.where(group_id: groups.map(&:id)).as(opts[:as]).destroy_all
+            else
+              super(*groups)
+            end
+          end
+        end
+      end
+
+      def in_group?(group, opts={})
+        criteria = {group_id: group.id}
+
+        if opts[:as]
+          criteria.merge!(membership_type: opts[:as])
+        end
+
+        group_memberships.exists?(criteria)
+      end
+
+      def in_any_group?(*args)
+        opts = args.extract_options!
+        groups = args
+
+        groups.flatten.each do |group|
+          return true if in_group?(group, opts)
+        end
+        return false
+      end
+
+      def in_all_groups?(*args)
+        opts = args.extract_options!
+        groups = args.flatten
+
+        groups.to_set.subset? self.groups.as(opts[:as]).to_set
+      end
+
+      def in_only_groups?(*args)
+        opts = args.extract_options!
+        groups = args.flatten
+
+        groups.to_set == self.groups.as(opts[:as]).to_set
+      end
+
+      def shares_any_group?(other, opts={})
+        in_any_group?(other.groups, opts)
+      end
+
+      module ClassMethods
+        def group_class_name; @group_class_name ||= 'Group'; end
+        def group_class_name=(klass);  @group_class_name = klass; end
+
+        def as(membership_type)
+          joins(:group_memberships).where(group_memberships: { membership_type: membership_type })
+        end
+
+        def in_group(group)
+          return none unless group.present?
+
+          joins(:group_memberships).where(group_memberships: { group_id: group.id }).uniq
+        end
+
+        def in_any_group(*groups)
+          groups = groups.flatten
+          return none unless groups.present?
+
+          joins(:group_memberships).where(group_memberships: { group_id: groups.map(&:id) }).uniq
+        end
+
+        def in_all_groups(*groups)
+          groups = groups.flatten
+          return none unless groups.present?
+
+          joins(:group_memberships).
+              group(:"group_memberships.member_id").
+              where(:group_memberships => {:group_id => groups.map(&:id)}).
+              having("COUNT(group_memberships.group_id) = #{groups.count}").
+              uniq
+        end
+
+        def in_only_groups(*groups)
+          groups = groups.flatten
+          return none unless groups.present?
+
+          joins(:group_memberships).
+              group(:"group_memberships.member_id").
+              having("COUNT(DISTINCT group_memberships.group_id) = #{groups.count}").
+              uniq
+        end
+
+        def shares_any_group(other)
+          in_any_group(other.groups)
+        end
+
+      end
+    end
+  end
+end

data/lib/groupify/adapter/active_record/group_membership.rb

@@ -0,0 +1,49 @@
+module Groupify
+  module ActiveRecord
+
+    # Join table that tracks which members belong to which groups
+    #
+    # Usage:
+    #    class GroupMembership < ActiveRecord::Base
+    #        acts_as_group_membership
+    #        ...
+    #    end
+    #
+    module GroupMembership
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessible(:member, :group, :group_name, :membership_type, :as) if ActiveSupport::VERSION::MAJOR < 4
+
+        belongs_to :member, :polymorphic => true
+        belongs_to :group
+      end
+
+      def membership_type=(membership_type)
+        self[:membership_type] = membership_type.to_s if membership_type.present?
+      end
+
+      def as=(membership_type)
+        self.membership_type = membership_type
+      end
+
+      def as
+        membership_type
+      end
+
+      module ClassMethods
+        def named(group_name=nil)
+          if group_name.present?
+            where(group_name: group_name)
+          else
+            where("group_name IS NOT NULL")
+          end
+        end
+
+        def as(membership_type)
+          where(membership_type: membership_type)
+        end
+      end
+    end
+  end
+end

data/lib/groupify/adapter/active_record/model.rb

@@ -0,0 +1,48 @@
+module Groupify
+  module ActiveRecord
+    module Model
+      extend ActiveSupport::Concern
+
+      included do
+        # Define a scope that returns nothing.
+        # This is built into ActiveRecord 4, but not 3
+        unless self.class.respond_to? :none
+          def self.none
+            where(arel_table[:id].eq(nil).and(arel_table[:id].not_eq(nil)))
+          end
+        end
+      end
+
+      module ClassMethods
+        def acts_as_group(opts = {})
+          include Groupify::ActiveRecord::Group
+
+          if (member_klass = opts.delete :default_members)
+            self.default_member_class = member_klass.to_s.classify.constantize
+          end
+
+          if (member_klasses = opts.delete :members)
+            member_klasses.each do |member_klass|
+              has_members(member_klass)
+            end
+          end
+        end
+
+        def acts_as_group_member(opts = {})
+          @group_class_name = opts[:class_name] || 'Group'
+          include Groupify::ActiveRecord::GroupMember
+        end
+
+        def acts_as_named_group_member(opts = {})
+          include Groupify::ActiveRecord::NamedGroupMember
+        end
+
+        def acts_as_group_membership(opts = {})
+          include Groupify::ActiveRecord::GroupMembership
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Groupify::ActiveRecord::Model

data/lib/groupify/adapter/active_record/named_group_collection.rb

@@ -0,0 +1,105 @@
+module Groupify
+  module ActiveRecord
+
+    class NamedGroupCollection < Set
+      def initialize(member)
+        @member = member
+        @named_group_memberships = member.group_memberships.named
+        @group_names = @named_group_memberships.pluck(:group_name).map(&:to_sym)
+        super(@group_names)
+      end
+
+      def add(named_group, opts={})
+        named_group = named_group.to_sym
+        membership_type = opts[:as]
+
+        if @member.new_record?
+          @member.group_memberships.build(group_name: named_group, membership_type: nil)
+        else
+          @member.transaction do
+            @member.group_memberships.where(group_name: named_group, membership_type: nil).first_or_create!
+          end
+        end
+
+        if membership_type
+          if @member.new_record?
+            @member.group_memberships.build(group_name: named_group, membership_type: membership_type)
+          else
+            @member.group_memberships.where(group_name: named_group, membership_type: membership_type).first_or_create!
+          end
+        end
+
+        super(named_group)
+      end
+
+      alias_method :push, :add
+      alias_method :<<, :add
+
+      def merge(*args)
+        opts = args.extract_options!
+        named_groups = args.flatten
+        named_groups.each do |named_group|
+          add(named_group, opts)
+        end
+      end
+
+      alias_method :concat, :merge
+
+      def include?(named_group, opts={})
+        named_group = named_group.to_sym
+        if opts[:as]
+          as(opts[:as]).include?(named_group)
+        else
+          super(named_group)
+        end
+      end
+
+      def delete(*args)
+        opts = args.extract_options!
+        named_groups = args.flatten.compact
+
+        remove(named_groups, :delete_all, opts)
+      end
+
+      def destroy(*args)
+        opts = args.extract_options!
+        named_groups = args.flatten.compact
+
+        remove(named_groups, :destroy_all, opts)
+      end
+
+      def clear
+        @named_group_memberships.delete_all
+        super
+      end
+
+      alias_method :delete_all, :clear
+      alias_method :destroy_all, :clear
+
+      # Criteria to filter by membership type
+      def as(membership_type)
+        @named_group_memberships.as(membership_type).pluck(:group_name).map(&:to_sym)
+      end
+
+      protected
+
+      def remove(named_groups, method, opts)
+        if named_groups.present?
+          scope = @named_group_memberships.where(group_name: named_groups)
+
+          if opts[:as]
+            scope = scope.where(membership_type: opts[:as])
+          end
+
+          scope.send(method)
+
+          unless opts[:as]
+            named_groups.each do |named_group|
+              @hash.delete(named_group)
+            end
+          end
+        end
+      end
+    end
+  end
+end