groupify 0.3.1 → 0.4.0

data/.travis.yml

@@ -1,27 +1,11 @@
 language: ruby
 services: mongodb
 rvm:
-  - ree
-  - 1.8.7
   - 1.9.3
   - 2.0.0
-  - jruby-18mode # JRuby in 1.8 mode
   - jruby-19mode # JRuby in 1.9 mode
-  - rbx-18mode
   - rbx-19mode
 gemfile:
-  - gemfiles/mongoid2.gemfile
-  - gemfiles/mongoid3.gemfile
-matrix:
-  exclude:
-    - rvm: 1.8.7
-      gemfile: gemfiles/mongoid3.gemfile
-    - rvm: ree
-      gemfile: gemfiles/mongoid3.gemfile
-    - rvm: jruby-18mode
-      gemfile: gemfiles/mongoid3.gemfile
-    - rvm: rbx-18mode
-      gemfile: gemfiles/mongoid3.gemfile
-  allow_failures:
-    - rvm: rbx-18mode
+  - gemfiles/activesupport3.gemfile
+  - gemfiles/activesupport4.gemfile
 

data/Gemfile

@@ -1,4 +1,14 @@
-source :rubygems
+source 'https://rubygems.org'
 
 # 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
+

data/README.md

@@ -1,8 +1,11 @@
-# Groupify [![Build Status](https://secure.travis-ci.org/dwbutler/groupify.png)](http://travis-ci.org/dwbutler/groupify)
+# 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)
 Adds group and membership functionality to Rails models.
 
-Currently only Mongoid 2 and 3 are supported. Tested in Ruby 1.8.7 and 1.9.3 (MRI, REE, JRuby, and Rubinius).
-It shouldn't be difficult to adapt to ActiveRecord.
+The following ORMs are supported:
+Mongoid 3.1 & 4.0, ActiveRecord 3.2 & 4.0
+
+The following Rubies are supported:
+Ruby 1.9.3, 2.0.0 (MRI, REE, JRuby, and Rubinius).
 
 ## Installation
 
@@ -19,28 +22,75 @@ Or install it yourself as:
     $ gem install groupify
 
 ## Getting Started
+
+### Active Record
+Add a migration similar to the following:
+
+```ruby
+class CreateGroups < ActiveRecord::Migration
+  def change
+    create_table :groups do |t|
+      t.string     :type      # Only needed if using single table inheritence
+    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)
+    end
+
+    add_index :group_memberships, [:member_id, :member_type]
+    add_index :group_memberships, :group_id
+    add_index :group_memberships, :group_name
+  end
+end
+```
+
+In your group model:
+
+```ruby
+class Group < ActiveRecord::Base  
+  acts_as_group :members => [:users, :assignments], :default_members => :users
+end
+```
+
+In your member models (i.e. `User`):
+
+```ruby
+class User < ActiveRecord::Base
+  acts_as_group_member
+  acts_as_named_group_member
+end
+
+class Assignment < ActiveRecord::Base
+  acts_as_group_member
+end
+```
+
+### Mongoid
 In your group model:
 
 ```ruby
 class Group
-	include Mongoid::Document
+  include Mongoid::Document
 
-	acts_as_group
+  acts_as_group :members => [:users], :default_members => :users
 end
 ```
 
-In your user model:
+In your member models (i.e. `User`):
 
 ```ruby
 class User
-	include Mongoid::Document
-	
-	acts_as_group_member
-	acts_as_named_group_member
+  include Mongoid::Document
+  
+  acts_as_group_member
+  acts_as_named_group_member
 end
 ```
 
-## Usage
+## Basic Usage
 
 Create groups and add members:
 
@@ -49,20 +99,22 @@ group = Group.new
 user = User.new
 
 user.groups << group
-or
+# or
 group.add user
 
-user.in_group?(group)	=> true
+user.in_group?(group)
+# => true
 ```
 
 Add to named groups:
 
 ```ruby
 user.named_groups << :admin
-user.in_named_group?(:admin)	=> true
+user.in_named_group?(:admin)
+# => true
 ```
 
-Check if two group members share any of the same groups:
+Check if two members share any of the same groups:
 
 ```ruby
 user1.shares_any_group?(user2)
@@ -72,16 +124,44 @@ user2.shares_any_named_group?(user1)
 Query for groups & members:
 
 ```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_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
+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
+```
+
+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.
 
+## 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.
+
+### With CanCan
+
+```ruby
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    …
+    # Implements group 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
+  end
+end
+```
+
 ## Contributing
 
 1. Fork it

data/gemfiles/activesupport3.gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', "~> 3.2"
+gem "mongoid", ">= 3.0", "< 4"
+gem 'mongoid-rspec', '>= 1.5.1'
+
+gem 'database_cleaner'
+gem "rspec"
+gem "rake"
+
+platform :ruby do
+  gem 'sqlite3'
+end
+
+platform :jruby do
+  gem "jdbc-sqlite3"
+  gem "activerecord-jdbcsqlite3-adapter"
+end

data/gemfiles/activesupport4.gemfile

@@ -0,0 +1,23 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', "~> 4"
+
+# TODO: Enable once Mongoid 4 is released
+#gem "mongoid", ">= 4.0"
+
+gem "mongoid", :github => "mongoid/mongoid"
+gem 'mongoid-rspec'
+
+gem 'database_cleaner'
+gem "rspec"
+gem "rake"
+
+platform :ruby do
+  gem 'sqlite3'
+end
+
+platform :jruby do
+  gem "jdbc-sqlite3"
+  # See https://github.com/jruby/activerecord-jdbc-adapter/issues/253
+  gem "activerecord-jdbcsqlite3-adapter", :github => 'jruby/activerecord-jdbc-adapter', :branch => 'v1.3.0.beta2'
+end

data/groupify.gemspec

@@ -14,8 +14,13 @@ Gem::Specification.new do |gem|
   gem.name          = "groupify"
   gem.require_paths = ["lib"]
   gem.version       = Groupify::VERSION
-  
-  gem.add_dependency "mongoid", '>= 2'
+
+  gem.add_development_dependency "mongoid", ">= 3.1"
+  gem.add_development_dependency "activerecord", ">= 3.2"
+
+  unless defined?(JRUBY_VERSION)
+    gem.add_development_dependency "sqlite3"
+  end
   
   gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"

data/lib/groupify/adapter/active_record.rb

@@ -0,0 +1,318 @@
+require 'active_record'
+require 'set'
+
+# Groups and members
+module Groupify
+  module ActiveRecord
+    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
+
+    # 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
+      end
+      
+      def members
+        self.class.default_member_class.joins(:group_memberships).where(:group_memberships => {:member_type => self.class.default_member_class.to_s})
+      end
+
+      def member_classes
+        self.class.member_classes
+      end
+      
+      def add(member)
+        member.groups << self
+      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 ||= register(User)
+        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)
+
+          # Define specific members accessor, i.e. group.users
+          define_method name.to_s.pluralize.underscore do
+            klass.joins(:group_memberships).where(:group_memberships => {:group_id => self.id})
+          end
+        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
+          member_klass
+        end
+      end
+    end
+
+    # 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
+        belongs_to :member, :polymorphic => true
+        belongs_to :group
+      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
+      end
+    end
+
+    # Usage:
+    #    class User < ActiveRecord::Base
+    #        acts_as_group_member
+    #        ...
+    #    end
+    #
+    #    user.groups << group
+    #
+    module GroupMember
+      extend ActiveSupport::Concern
+      
+      included do
+        has_many :group_memberships, :as => :member, :autosave => true
+        has_many :groups, :through => :group_memberships, :class_name => @group_class_name
+      end
+      
+      def in_group?(group)
+        self.group_memberships.exists?(:group_id => group.id)
+      end
+      
+      def in_any_group?(*groups)
+        groups.flatten.each do |group|
+          return true if in_group?(group)
+        end
+        return false
+      end
+      
+      def in_all_groups?(*groups)
+        Set.new(groups.flatten) == Set.new(self.named_groups)
+      end
+      
+      def shares_any_group?(other)
+        in_any_group?(other.groups)
+      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? ? joins(:group_memberships).where(:group_memberships => {:group_id => group.id}) : none
+        end
+        
+        def in_any_group(*groups)
+          groups.present? ? joins(:group_memberships).where(:group_memberships => {:group_id => groups.flatten.map(&:id)}) : none
+        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}")
+          else
+            none
+          end
+        end
+        
+        def shares_any_group(other)
+          in_any_group(other.groups)
+        end
+        
+      end
+    end
+
+    class NamedGroupCollection < Set
+      def initialize(member)
+        @member = member
+        super(member.group_memberships.named.pluck(:group_name).map(&:to_sym))
+      end
+
+      def <<(named_group)
+        named_group = named_group.to_sym
+        unless include?(named_group)
+          @member.group_memberships.build(:group_name => named_group)
+          super(named_group)
+        end
+        named_group
+      end
+    end
+
+    
+    # Usage:
+    #    class User < ActiveRecord::Base
+    #        acts_as_named_group_member
+    #        ...
+    #    end
+    #
+    #    user.named_groups << :admin
+    #
+    module NamedGroupMember
+      extend ActiveSupport::Concern
+
+      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
+        end
+      end
+      
+      def in_named_group?(group)
+        named_groups.include?(group)
+      end
+      
+      def in_any_named_group?(*groups)
+        groups.flatten.each do |group|
+          return true if in_named_group?(group)
+        end
+        return false
+      end
+      
+      def in_all_named_groups?(*groups)
+        Set.new(groups.flatten) == Set.new(self.named_groups)
+      end
+      
+      def shares_any_named_group?(other)
+        in_any_named_group?(other.named_groups.to_a)
+      end
+      
+      module ClassMethods
+        def in_named_group(named_group)
+          named_group.present? ? joins(:group_memberships).where(:group_memberships => {:group_name => named_group})  : none
+        end
+        
+        def in_any_named_group(*named_groups)
+          named_groups.present? ? joins(:group_memberships).where(:group_memberships => {:group_name => named_groups.flatten}) : none
+        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}")
+          else
+            none
+          end
+        end
+        
+        def shares_any_named_group(other)
+          in_any_named_group(other.named_groups.to_a)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, Groupify::ActiveRecord