groupify 0.5.1 → 0.6.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6c1b6a28b9ffcb7a8fd8cdd22c7882e68b7fc33
-  data.tar.gz: 1b828c4275ba593ff14e4813117047faf668082b
+  metadata.gz: 688ba7945e95997b9bd71d248d9c8d0e17da2663
+  data.tar.gz: 6e239d414dd7098a5d36e1517ac25827187ea55e
 SHA512:
-  metadata.gz: abffefbf67162095c5943df53b394b1adb4bcf846e78909b37fec2e3b26db2d21e7c0bab6ae1f5888a6d280e1061590fb5968556d5d1b05255fce7bd37531226
-  data.tar.gz: c9db57ffa507fb16e2606fa2fd1bdb245d120e18cf66148d37a014a88b578b36ee4e1d679e35e21d9da6015c633c7e50cc778b346f4e1fd086e67e40d97eb1ea
+  metadata.gz: a9e8494ba575bf48cf3b1c439aba5fbfd512e08a51d998c48a84ea10738cd43d409c8588e053391a5f4a8da50b683dba8bf9ae57907c262d71a40fb930d0377f
+  data.tar.gz: 2ee79e0d86e422250f1bc6859707ba439009eb5d8ef95e47998f87e492e983cce22bd7153703f8dc446f5688374e65e7a95bd364286ca3e0378febfe6829f14d

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 /**/*.lock
+.idea/

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format progress
+--require spec_helper
+--pattern "spec/**/*_spec.rb"

data/.travis.yml

@@ -6,8 +6,11 @@ rvm:
   - 2.1.0
   - 2.1.1
   - jruby-19mode
-  #- rbx
+  - rbx-2
 gemfile:
-  - gemfiles/activesupport3.gemfile
-  - gemfiles/activesupport4.gemfile
-
+  - gemfiles/rails_3.2.gemfile
+  - gemfiles/rails_4.0.gemfile
+  - gemfiles/rails_4.1.gemfile
+matrix:
+  allow_failures:
+    - rvm: rbx-2

data/Appraisals

@@ -0,0 +1,24 @@
+appraise "rails-3.2" do
+  gem 'activerecord', "~> 3.2"
+  gem "mongoid", ">= 3.0", "< 4"
+end
+
+appraise "rails-4.0" do
+  gem 'activerecord', "~> 4.0.0"
+
+  # TODO: Enable once Mongoid 4 is released
+  #gem "mongoid", ">= 4.0"
+
+  #gem "mongoid", github: "mongoid/mongoid", branch: "master"
+  gem "mongoid", "4.0.0.rc2"
+end
+
+appraise "rails-4.1" do
+  gem 'activerecord', "~> 4.1.0"
+
+  # TODO: Enable once Mongoid 4 is released
+  #gem "mongoid", ">= 4.0"
+
+  #gem "mongoid", :github => "mongoid/mongoid"
+  gem "mongoid", "4.0.0.rc2"
+end

data/Gemfile

@@ -4,15 +4,12 @@ group :development do
   gem 'pry'
 end
 
+group :test do
+  gem 'coveralls', require: false
+end
+
 # Specify your gem's dependencies in groupify.gemspec
 gemspec
 
-platform :jruby do
-  gem "jdbc-sqlite3"
-  gem "activerecord-jdbcsqlite3-adapter"
-  
-  if defined?(RUBY_VERSION) && RUBY_VERSION < '1.9'
-    gem "json"
-  end
-end
-
+gem "jdbc-sqlite3", platform: :jruby
+gem "activerecord-jdbcsqlite3-adapter", platform: :jruby

data/README.md

@@ -1,6 +1,10 @@
-# Groupify [![Build Status](https://secure.travis-ci.org/dwbutler/groupify.png)](http://travis-ci.org/dwbutler/groupify) [![Dependency Status](https://gemnasium.com/dwbutler/groupify.png)](https://gemnasium.com/dwbutler/groupify) [![Code Climate](https://codeclimate.com/github/dwbutler/groupify.png)](https://codeclimate.com/github/dwbutler/groupify)
+# Groupify
+[![Build Status](https://secure.travis-ci.org/dwbutler/groupify.png)](http://travis-ci.org/dwbutler/groupify) [![Coverage Status](https://coveralls.io/repos/dwbutler/groupify/badge.png?branch=master)](https://coveralls.io/r/dwbutler/groupify?branch=master) [![Code Climate](https://codeclimate.com/github/dwbutler/groupify.png)](https://codeclimate.com/github/dwbutler/groupify) [![Dependency Status](https://gemnasium.com/dwbutler/groupify.png)](https://gemnasium.com/dwbutler/groupify)
 
-Adds group and membership functionality to Rails models.
+Adds group and membership functionality to Rails models. Defines a polymorphic
+relationship between a Group model and any member model. Don't need a Group
+model? Use named groups instead to add members to named groups such as
+`:admin` or `"Team Rocketpants"`.
 
 The following ORMs are supported:
 Mongoid 3.1 & 4.0, ActiveRecord 3.2 & 4.x
@@ -34,10 +38,11 @@ class CreateGroups < ActiveRecord::Migration
     end
     
     create_table :group_memberships do |t|
-      t.string     :member_type   # Needed to make polymorphic members work
-      t.integer    :member_id   # The member that belongs to this group
-      t.integer    :group_id    # The group to which the member belongs
-      t.string     :group_name    # Links a member to a named group (if using named groups)
+      t.string     :member_type     # Necessary to make polymorphic members work
+      t.integer    :member_id       # The id of the member that belongs to this group
+      t.integer    :group_id        # The group to which the member belongs
+      t.string     :group_name      # The named group to which a member belongs (if using)
+      t.string     :membership_type # The type of membership the member belongs with
     end
 
     add_index :group_memberships, [:member_id, :member_type]
@@ -100,7 +105,7 @@ end
 
 ## Basic Usage
 
-Create groups and add members:
+### Create groups and add members
 
 ```ruby
 group = Group.new
@@ -117,44 +122,129 @@ user.in_group?(group)
 group.add(user, widget, task)
 ```
 
-Add to named groups:
+### Add to named groups
 
 ```ruby
 user.named_groups << :admin
-user.in_named_group?(:admin)
-# => true
+user.in_named_group?(:admin)        # => true
+```
+
+### Remove from groups
+
+```ruby
+users.groups.destroy(group)          # Destroys this user's group membership for this group
+group.users.delete(user)             # Deletes this group's group membership for this user
+```
+
+### Check if two members share any of the same groups:
+
+```ruby
+user1.shares_any_group?(user2)          # Returns true if user1 and user2 are in any of the same groups
+user2.shares_any_named_group?(user1)    # Also works for named groups
 ```
 
-Check if two members share any of the same groups:
+### Query for groups & members:
 
 ```ruby
-user1.shares_any_group?(user2)
-user2.shares_any_named_group?(user1)
+User.in_group(group)                # Find all users in this group
+User.in_named_group(:admin)         # Find all users in this named group
+Group.with_member(user)             # Find all groups with this user
+
+User.shares_any_group(user)         # Find all users that share any groups with this user
+User.shares_any_named_group(user)   # Find all users that share any named groups with this user
 ```
 
-Query for groups & members:
+### Check if member belongs to any/all groups
 
 ```ruby
-User.in_group(group)         # Find all users in this group
-User.in_named_group(:admin)  # Find all users in this named group
-Group.with_member(user)      # Find all groups with this user
+User.in_any_group(group1, group2)               # Find users that belong to any of these groups
+User.in_all_groups(group1, group2)              # Find users that belong to all of these groups
+Widget.in_only_groups(group2, group3)           # Find widgets that belong to only these groups
 
-User.shares_any_group(user)       # Find all users that share any groups with this user
-User.shares_any_named_group(user) # Find all users that share any named groups with this user
+widget.in_any_named_group?(:foo, :bar)          # Check if widget belongs to any of these named groups
+user.in_all_named_groups?(:manager, :poster)    # Check if user belongs to all of these named groups
+user.in_only_named_groups?(:employee, :worker)  # Check if user belongs to only these named groups
 ```
 
-Merge one group into another:
+### Merge one group into another:
 
 ```ruby
 # Moves the members of source into destination, and destroys source
 destination_group.merge!(source_group)
 ```
 
-Check the specs for more details.
+## Membership Types
+
+Membership types allow a member to belong to a group in a more specific way. For example,
+you can add a user to a group with membership type of "manager" to specify that this
+user has the "manager role" on that group.
+
+This can be used to implement role-based authorization combined with group authorization,
+which could be used to mass-assign roles to groups of resources.
+
+It could also be used to add users and resources to the same "sub-group" or "project"
+within a larger group (say, an organization).
+
+```ruby
+# Add user to group as a specific membership type
+group.add(user, as: 'manager')
+
+# Works with named groups too
+user.named_groups.add user, as: 'manager'
+
+# Query for the groups that a user belongs to with a certain role
+user.groups.as(:manager)
+user.named_groups.as('manager')
+Group.with_member(user).as('manager')
+
+# Remove a member's membership type from a group
+group.users.delete(user, as: 'manager')         # Deletes this group's 'manager' group membership for this user
+user.groups.destroy(group, as: 'employee')      # Destroys this user's 'employee' group membership for this group
+user.groups.destroy(group)                      # Destroys any membership types this user had in this group
+
+# Find all members that have a certain membership type in a group
+User.in_group(group).as(:manager)
+
+# Find all members of a certain membership type regardless of group
+User.as(:manager)    # Find users that are managers, we don't care what group
+
+# Check if a member belongs to any/all groups with a certain membership type
+user.in_all_groups?(group1, group2, as: 'manager')
+
+# Find all members that share the same group with the same membership type
+Widget.shares_any_group(user).as("Moon Launch Project")
+
+# Check is one member belongs to the same group as another member with a certain membership type
+user.shares_any_group?(widget, as: 'employee')
+```
+
+Note that adding a member to a group with a specific membership type will automatically
+add them to that group without a specific membership type. This way you can still query
+`groups` and find the member in that group. If you then remove that specific membership
+type, they still remain in the group without a specific membership type.
+
+Removing a member from a group will bulk remove any specific membership types as well.
+
+```
+group.add(manager, as: 'manager')
+manager.groups.include?(group)              # => true
+
+manager.groups.delete(group, as: 'manager')
+manager.groups.include?(group)              # => true
+
+group.add(employee, as: 'employee')
+employee.groups.delete(group)
+employee.in_group?(group)                   # => false
+employee.in_group?(group, as: 'employee')   # => false
+```
+
+## But wait, there's more!
+
+Check the specs for a complete list of methods and scopes provided by Groupify.
 
 ## Using for Authorization
 Groupify was originally created to help implement user authorization, although it can be used
-generically for much more than that. Here is how to do it.
+generically for much more than that. Here are some examples of how to do it.
 
 ### With CanCan
 
@@ -163,9 +253,8 @@ class Ability
   include CanCan::Ability
 
   def initialize(user)
-    …
-    # Implements group authorization
-    # Users can only manage assignment which belong to the same group
+    # Implements group-based authorization
+    # Users can only manage assignment which belong to the same group.
     can [:manage], Assignment, Assignment.shares_any_group(user) do |assignment|
       assignment.shares_any_group?(user)
     end
@@ -173,6 +262,73 @@ class Ability
 end
 ```
 
+### With Authority
+
+```ruby
+# Whatever class represents a logged-in user in your app
+class User
+  acts_as_named_group_member
+  include Authority::UserAbilities
+end
+
+class Widget
+  acts_as_named_group_member
+  include Authority::Abilities
+end
+
+class WidgetAuthorizer  < ApplicationAuthorizer
+  # Implements group-based authorization using named groups.
+  # Users can only see widgets which belong to the same named group.
+  def readable_by?(user)
+    user.shares_any_named_group?(resource)
+  end
+
+  # Implements combined role-based and group-based authorization.
+  # Widgets can only be updated by users that are employees of the same named group.
+  def updateable_by?(user)
+    user.shares_any_named_group?(resource, as: :employee)
+  end
+
+  # Widgets can only be deleted by users that are managers of the same named group.
+  def deletable_by?(user)
+    user.shares_any_named_group?(resource, as: :manager)
+  end
+end
+
+user = User.create!
+user.named_groups.add(:team1, as: :employee)
+
+widget = Widget.create!
+widget.named_groups << :team1
+
+widget.readable_by?(user) # => true
+user.can_update?(widget)  # => true
+user.can_delete?(widget)  # => false
+```
+
+### With Pundit
+
+```ruby
+class PostPolicy < Struct.new(:user, :post)
+  # User can only update a published post if they are admin of the same group.
+  def update?
+    user.shares_any_group?(post, as: :admin) || !post.published?
+  end
+
+  class Scope < Struct.new(:user, :scope)
+    def resolve
+      if user.admin?
+        # An admin can see all the posts in the group(s) they are admin for
+        scope.shares_any_group(user).as(:admin)
+      else
+        # Normal users can only see published posts in the same group(s).
+        scope.shares_any_group(user).where(published: true)
+      end
+    end
+  end
+end
+```
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1,4 +1,5 @@
 #!/usr/bin/env rake
+require "bundler/setup"
 require "bundler/gem_tasks"
 
 require 'rspec/core/rake_task'

data/gemfiles/rails_3.2.gemfile

@@ -0,0 +1,18 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "jdbc-sqlite3", :platform => :jruby
+gem "activerecord-jdbcsqlite3-adapter", :platform => :jruby
+gem "activerecord", "~> 3.2"
+gem "mongoid", ">= 3.0", "< 4"
+
+group :development do
+  gem "pry"
+end
+
+group :test do
+  gem "coveralls", :require => false
+end
+
+gemspec :path => "../"

data/gemfiles/rails_4.0.gemfile

@@ -0,0 +1,18 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "jdbc-sqlite3", :platform => :jruby
+gem "activerecord-jdbcsqlite3-adapter", :platform => :jruby
+gem "activerecord", "~> 4.0.0"
+gem "mongoid", "4.0.0.rc2"
+
+group :development do
+  gem "pry"
+end
+
+group :test do
+  gem "coveralls", :require => false
+end
+
+gemspec :path => "../"

data/gemfiles/rails_4.1.gemfile

@@ -0,0 +1,18 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "jdbc-sqlite3", :platform => :jruby
+gem "activerecord-jdbcsqlite3-adapter", :platform => :jruby
+gem "activerecord", "~> 4.1.0"
+gem "mongoid", "4.0.0.rc2"
+
+group :development do
+  gem "pry"
+end
+
+group :test do
+  gem "coveralls", :require => false
+end
+
+gemspec :path => "../"

data/groupify.gemspec

@@ -24,8 +24,8 @@ Gem::Specification.new do |gem|
   end
   
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "rspec"
-  
-  gem.add_development_dependency 'mongoid-rspec'
-  gem.add_development_dependency 'database_cleaner'
+  gem.add_development_dependency "rspec", ">= 3"
+
+  gem.add_development_dependency "database_cleaner"
+  gem.add_development_dependency "appraisal"
 end

data/lib/groupify/adapter/active_record.rb

@@ -68,11 +68,20 @@ module Groupify
         self.class.member_classes
       end
       
-      def add(*members)
+      def add(*args)
+        opts = args.extract_options!
+        membership_type = opts[:as]
+        members = args.flatten
+        return unless members.present?
+
         clear_association_cache
         
-        members.flatten.each do |member|
-          member.groups << self
+        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, membership_type: membership_type).first_or_create!
+          end
+          member.clear_association_cache
         end
       end
 
@@ -132,13 +141,62 @@ module Groupify
           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
+
+          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
+            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
@@ -156,10 +214,24 @@ module Groupify
       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?
@@ -168,6 +240,10 @@ module Groupify
             where("group_name IS NOT NULL")
           end
         end
+
+        def as(membership_type)
+          where(membership_type: membership_type)
+        end
       end
     end
 
@@ -183,53 +259,118 @@ module Groupify
       extend ActiveSupport::Concern
       
       included do
-        has_many :group_memberships, :as => :member, :autosave => true, :dependent => :destroy
-        has_many :groups, :through => :group_memberships, :class_name => @group_class_name
+        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)
-        self.group_memberships.exists?(:group_id => group.id)
+      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?(*groups)
+      def in_any_group?(*args)
+        opts = args.extract_options!
+        groups = args
+
         groups.flatten.each do |group|
-          return true if in_group?(group)
+          return true if in_group?(group, opts)
         end
         return false
       end
       
-      def in_all_groups?(*groups)
-        Set.new(groups.flatten) == Set.new(self.named_groups)
+      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)
-        in_any_group?(other.groups)
+      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)
-          group.present? ? joins(:group_memberships).where(:group_memberships => {:group_id => group.id}).uniq : none
+          return none unless group.present?
+
+          joins(:group_memberships).where(group_memberships: { group_id: group.id }).uniq
         end
         
         def in_any_group(*groups)
-          groups.present? ? joins(:group_memberships).where(:group_memberships => {:group_id => groups.flatten.map(&:id)}).uniq : none
+          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)
-          if groups.present?
-            groups = groups.flatten
-
-            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
-          else
-            none
-          end
+          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)
@@ -242,16 +383,101 @@ module Groupify
     class NamedGroupCollection < Set
       def initialize(member)
         @member = member
-        super(member.group_memberships.named.pluck(:group_name).map(&:to_sym))
+        @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
 
-      def <<(named_group)
+      alias_method :concat, :merge
+
+      def include?(named_group, opts={})
         named_group = named_group.to_sym
-        unless include?(named_group)
-          @member.group_memberships.build(:group_name => named_group)
+        if opts[:as]
+          as(opts[:as]).include?(named_group)
+        else
           super(named_group)
         end
-        named_group
+      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
 
@@ -267,56 +493,88 @@ module Groupify
     module NamedGroupMember
       extend ActiveSupport::Concern
 
+      included do
+        unless respond_to?(:group_memberships)
+          has_many :group_memberships, :as => :member, :autosave => true, :dependent => :destroy
+        end
+      end
+
       def named_groups
         @named_groups ||= NamedGroupCollection.new(self)
       end
 
-      def named_groups=(named_groups)
-        named_groups.each do |named_group|
-          self.named_groups << named_group
+      def named_groups=(groups)
+        groups.each do |group|
+          self.named_groups << group
         end
       end
       
-      def in_named_group?(group)
-        named_groups.include?(group)
+      def in_named_group?(named_group, opts={})
+        named_groups.include?(named_group, opts)
       end
       
-      def in_any_named_group?(*groups)
-        groups.flatten.each do |group|
-          return true if in_named_group?(group)
+      def in_any_named_group?(*args)
+        opts = args.extract_options!
+        named_groups = args.flatten
+        named_groups.each do |named_group|
+          return true if in_named_group?(named_group, opts)
         end
         return false
       end
       
-      def in_all_named_groups?(*groups)
-        Set.new(groups.flatten) == Set.new(self.named_groups)
+      def in_all_named_groups?(*args)
+        opts = args.extract_options!
+        named_groups = args.flatten.to_set
+        named_groups.subset? self.named_groups.as(opts[:as]).to_set
+      end
+
+      def in_only_named_groups?(*args)
+        opts = args.extract_options!
+        named_groups = args.flatten.to_set
+        named_groups == self.named_groups.as(opts[:as]).to_set
       end
       
-      def shares_any_named_group?(other)
-        in_any_named_group?(other.named_groups.to_a)
+      def shares_any_named_group?(other, opts={})
+        in_any_named_group?(other.named_groups.to_a, opts)
       end
       
       module ClassMethods
+        def as(membership_type)
+          joins(:group_memberships).where(group_memberships: {membership_type: membership_type})
+        end
+
         def in_named_group(named_group)
-          named_group.present? ? joins(:group_memberships).where(:group_memberships => {:group_name => named_group}).uniq  : none
+          return none unless named_group.present?
+
+          joins(:group_memberships).where(group_memberships: {group_name: named_group}).uniq
         end
         
         def in_any_named_group(*named_groups)
-          named_groups.present? ? joins(:group_memberships).where(:group_memberships => {:group_name => named_groups.flatten}).uniq : none
+          named_groups.flatten!
+          return none unless named_groups.present?
+
+          joins(:group_memberships).where(group_memberships: {group_name: named_groups.flatten}).uniq
         end
-        
+
         def in_all_named_groups(*named_groups)
-          if named_groups.present?
-            named_groups = named_groups.flatten.map(&:to_s)
-
-            joins(:group_memberships).
-            group(:"group_memberships.member_id").
-            where(:group_memberships => {:group_name => named_groups}).
-            having("COUNT(group_memberships.group_name) = #{named_groups.count}").
-            uniq
-          else
-            none
-          end
+          named_groups.flatten!
+          return none unless named_groups.present?
+
+          joins(:group_memberships).
+          group(:"group_memberships.member_id").
+          where(:group_memberships => {:group_name => named_groups}).
+          having("COUNT(DISTINCT group_memberships.group_name) = #{named_groups.count}").
+          uniq
+        end
+
+        def in_only_named_groups(*named_groups)
+          named_groups.flatten!
+          return none unless named_groups.present?
+
+          joins(:group_memberships).
+          group("group_memberships.member_id").
+          having("COUNT(DISTINCT group_memberships.group_name) = #{named_groups.count}").
+          uniq
         end
         
         def shares_any_named_group(other)