groupify 0.6.0.rc1 → 0.6.0.rc2

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

@@ -0,0 +1,150 @@
+module Groupify
+  module Mongoid
+
+    # Usage:
+    #    class Group
+    #      include Mongoid::Document
+    #
+    #      acts_as_group, :members => [:users]
+    #      ...
+    #    end
+    #
+    #   group.add(member)
+    #
+    module Group
+      extend ActiveSupport::Concern
+
+      included do
+        @default_member_class = nil
+        @member_klasses ||= Set.new
+      end
+
+      # def members
+      #   self.class.default_member_class.any_in(:group_ids => [self.id])
+      # 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?
+
+        members.each do |member|
+          member.groups << self
+          membership = member.group_memberships.find_or_initialize_by(as: membership_type)
+          membership.groups << self
+          membership.save!
+        end
+      end
+
+      # Merge a source group into this group.
+      def merge!(source)
+        self.class.merge!(source, self)
+      end
+
+      module ClassMethods
+        def with_member(member)
+          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.in(group_ids: [source_group.id]).count > 0
+              raise ArgumentError.new("#{source_group.class} has members that cannot belong to #{destination_group.class}")
+            end
+          end
+
+          source_group.member_classes.each do |klass|
+            klass.in(group_ids: [source_group.id]).update_all(:$set => {:"group_ids.$" => destination_group.id})
+
+            if klass.relations['group_memberships']
+              if ::Mongoid::VERSION > "4"
+                klass.in(:"group_memberships.group_ids" => [source_group.id]).add_to_set(:"group_memberships.$.group_ids" => destination_group.id)
+                klass.in(:"group_memberships.group_ids" => [source_group.id]).pull(:"group_memberships.$.group_ids" => source_group.id)
+              else
+                klass.in(:"group_memberships.group_ids" => [source_group.id]).add_to_set(:"group_memberships.$.group_ids", destination_group.id)
+                klass.in(:"group_memberships.group_ids" => [source_group.id]).pull(:"group_memberships.$.group_ids", source_group.id)
+              end
+            end
+          end
+
+          source_group.delete
+        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)
+            return self unless membership_type
+            where(:group_memberships.elem_match => { as: membership_type.to_s, group_ids: [base.id] })
+          end
+
+          def destroy(*args)
+            delete(*args)
+          end
+
+          def delete(*args)
+            opts = args.extract_options!
+            members = args
+
+            if opts[:as]
+              members.each do |member|
+                member.group_memberships.as(opts[:as]).first.groups.delete(base)
+              end
+            else
+              members.each do |member|
+                member.group_memberships.in(groups: base).each do |membership|
+                  membership.groups.delete(base)
+                end
+              end
+
+              super(*members)
+            end
+          end
+        end
+
+        def associate_member_class(member_klass)
+          association_name = member_klass.name.to_s.pluralize.underscore.to_sym
+
+          has_many association_name, class_name: member_klass.to_s, dependent: :nullify, foreign_key: 'group_ids', extend: MemberAssociationExtensions
+
+          if member_klass == default_member_class
+            has_many :members, class_name: member_klass.to_s, dependent: :nullify, foreign_key: 'group_ids', extend: MemberAssociationExtensions
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+module Groupify
+  module Mongoid
+
+    # Usage:
+    #    class User
+    #      include Mongoid::Document
+    #
+    #      acts_as_group_member
+    #      ...
+    #    end
+    #
+    #    user.groups << group
+    #
+    module GroupMember
+      extend ActiveSupport::Concern
+      include MemberScopedAs
+
+      included do
+        has_and_belongs_to_many :groups, autosave: true, dependent: :nullify, inverse_of: nil, class_name: @group_class_name do
+          def as(membership_type)
+            return self unless membership_type
+            group_ids = base.group_memberships.as(membership_type).first.group_ids
+
+            if group_ids.present?
+              self.and(:id.in => group_ids)
+            else
+              self.and(:id => nil)
+            end
+          end
+
+          def destroy(*args)
+            delete(*args)
+          end
+
+          def delete(*args)
+            opts = args.extract_options!
+            groups = args.flatten
+
+
+            if opts[:as]
+              base.group_memberships.as(opts[:as]).each do |membership|
+                membership.groups.delete(*groups)
+              end
+            else
+              super(*groups)
+            end
+          end
+        end
+
+        class GroupMembership
+          include ::Mongoid::Document
+
+          embedded_in :member, polymorphic: true
+
+          field :named_groups, type: Array, default: -> { [] }
+
+          after_initialize do
+            named_groups.extend NamedGroupCollection
+          end
+
+          field :as, as: :membership_type, type: String
+        end
+
+        GroupMembership.send :has_and_belongs_to_many, :groups, class_name: @group_class_name, inverse_of: nil
+
+        embeds_many :group_memberships, class_name: GroupMembership.to_s, as: :member do
+          def as(membership_type)
+            where(membership_type: membership_type.to_s)
+          end
+        end
+      end
+
+      def in_group?(group, opts={})
+        groups.as(opts[:as]).include?(group)
+      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
+
+        groups.flatten.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.to_a, opts)
+      end
+
+      module ClassMethods
+        def group_class_name; @group_class_name ||= 'Group'; end
+        def group_class_name=(klass);  @group_class_name = klass; end
+
+        def in_group(group)
+          group.present? ? self.in(group_ids: group.id) : none
+        end
+
+        def in_any_group(*groups)
+          groups.present? ? self.in(group_ids: groups.flatten.map(&:id)) : none
+        end
+
+        def in_all_groups(*groups)
+          groups.present? ? where(:group_ids.all => groups.flatten.map(&:id)) : none
+        end
+
+        def in_only_groups(*groups)
+          groups.present? ? where(:group_ids => groups.flatten.map(&:id)) : none
+        end
+
+        def shares_any_group(other)
+          in_any_group(other.groups.to_a)
+        end
+
+      end
+    end
+  end
+end

data/lib/groupify/adapter/mongoid/member_scoped_as.rb

@@ -0,0 +1,37 @@
+module Groupify
+  module Mongoid
+
+    module MemberScopedAs
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def as(membership_type)
+          group_ids = criteria.selector["group_ids"]
+          named_groups = criteria.selector["named_groups"]
+          criteria = self.criteria
+
+          # If filtering by groups or named groups, merge into the group membership criteria
+          if group_ids || named_groups
+            elem_match = {as: membership_type}
+
+            if group_ids
+              elem_match.merge!(group_ids: group_ids)
+            end
+
+            if named_groups
+              elem_match.merge!(named_groups: named_groups)
+            end
+
+            criteria = where(:group_memberships.elem_match => elem_match)
+            criteria.selector.delete("group_ids")
+            criteria.selector.delete("named_groups")
+          else
+            criteria = where(:"group_memberships.as" => membership_type)
+          end
+
+          criteria
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Groupify
+  module Mongoid
+    module Model
+      extend ActiveSupport::Concern
+
+      included do
+        def none; where(:id => nil); end
+      end
+
+      module ClassMethods
+        def acts_as_group(opts = {})
+          include Groupify::Mongoid::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::Mongoid::GroupMember
+        end
+
+        def acts_as_named_group_member(opts = {})
+          include Groupify::Mongoid::NamedGroupMember
+        end
+      end
+    end
+  end
+end
+
+Mongoid::Document.send :include, Groupify::Mongoid::Model

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

@@ -0,0 +1,87 @@
+module Groupify
+  module Mongoid
+
+    module NamedGroupCollection
+      # Criteria to filter by membership type
+      def as(membership_type)
+        return self unless membership_type
+
+        membership = @member.group_memberships.as(membership_type).first
+        if membership
+          membership.named_groups
+        else
+          self.class.new
+        end
+      end
+
+      def <<(named_group, opts={})
+        named_group = named_group.to_sym
+        super(named_group)
+        uniq!
+
+        if @member && opts[:as]
+          membership = @member.group_memberships.find_or_initialize_by(as: opts[:as])
+          membership.named_groups << named_group
+          membership.save!
+        end
+
+        self
+      end
+
+      def merge(*args)
+        opts = args.extract_options!
+        named_groups = args.flatten
+
+        named_groups.each do |named_group|
+          add(named_group, opts)
+        end
+      end
+
+      def delete(*args)
+        opts = args.extract_options!
+        named_groups = args.flatten
+
+        if @member
+          if opts[:as]
+            membership = @member.group_memberships.as(opts[:as]).first
+            if membership
+              if ::Mongoid::VERSION > "4"
+                membership.pull_all(named_groups: named_groups)
+              else
+                membership.pull_all(:named_groups, named_groups)
+              end
+            end
+
+            return
+          else
+            memberships = @member.group_memberships.where(:named_groups.in => named_groups)
+            memberships.each do |membership|
+              if ::Mongoid::VERSION > "4"
+                membership.pull_all(named_groups: named_groups)
+              else
+                membership.pull_all(:named_groups, named_groups)
+              end
+            end
+          end
+        end
+
+        named_groups.each do |named_group|
+          super(named_group)
+        end
+      end
+
+      def self.extended(base)
+        base.class_eval do
+          attr_accessor :member
+
+          alias_method :delete_all, :clear
+          alias_method :destroy_all, :clear
+          alias_method :push, :<<
+          alias_method :add, :<<
+          alias_method :concat, :merge
+          alias_method :destroy, :delete
+        end
+      end
+    end
+  end
+end