groupify 0.3.1 → 0.4.0

data/lib/groupify/adapter/mongoid.rb

@@ -0,0 +1,249 @@
+require 'mongoid'
+require 'set'
+
+# Groups and members
+module Groupify
+  module Mongoid
+    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
+
+    # 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(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)
+          criteria.for_ids(member.group_ids)
+        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.any_in(:group_ids => [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.any_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.any_in(:group_ids => [source_group.id]).update(:$set => {:"group_ids.$" => destination_group.id})
+          end
+          source_group.destroy
+        end
+
+        protected
+
+        def register(member_klass)
+          (@member_klasses ||= Set.new) << member_klass
+          member_klass
+        end
+      end
+    end
+    
+    # Usage:
+    #    class User
+    #      include Mongoid::Document
+    #
+    #      acts_as_group_member
+    #      ...
+    #    end
+    #
+    #    user.groups << group
+    #
+    module GroupMember
+      extend ActiveSupport::Concern
+      
+      included do
+        has_and_belongs_to_many :groups, :autosave => true, :inverse_of => nil, :class_name => @group_class_name
+      end
+      
+      def in_group?(group)
+        self.groups.include?(group)
+      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? ? where(:group_ids.in => [group.id]) : none
+        end
+        
+        def in_any_group(*groups)
+          groups.present? ? where(:group_ids.in => groups.flatten.map(&:id)) : none
+        end
+        
+        def in_all_groups(*groups)
+          groups.present? ? where(:group_ids => groups.flatten.map(&:id)) : none
+        end
+        
+        def shares_any_group(other)
+          in_any_group(other.groups)
+        end
+        
+      end
+    end
+    
+    # Usage:
+    #    class User
+    #      include Mongoid::Document
+    #
+    #      acts_as_named_group_member
+    #      ...
+    #    end
+    #
+    #    user.named_groups << :admin
+    #
+    module NamedGroupMember
+      extend ActiveSupport::Concern
+      
+      included do
+        field :named_groups, :type => Array, :default => []
+        
+        before_save :uniq_named_groups
+        protected
+        def uniq_named_groups
+          named_groups.uniq!
+        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)
+      end
+      
+      module ClassMethods
+        def in_named_group(named_group)
+          named_group.present? ? where(:named_groups.in => [named_group]) : none
+        end
+        
+        def in_any_named_group(*named_groups)
+          named_groups.present? ? where(:named_groups.in => named_groups.flatten) : none
+        end
+        
+        def in_all_named_groups(*named_groups)
+          named_groups.present? ? where(:named_groups => named_groups.flatten) : none
+        end
+        
+        def shares_any_named_group(other)
+          in_any_named_group(other.named_groups)
+        end
+      end
+    end
+  end
+end
+
+Mongoid::Document.send :include, Groupify::Mongoid

data/lib/groupify/railtie.rb

@@ -0,0 +1,20 @@
+require 'groupify'
+require 'rails'
+
+module Groupify
+  class Railtie < Rails::Railtie
+
+    initializer "groupify.active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        require 'groupify/adapter/active_record'
+      end
+    end
+    
+    initializer "groupify.mongoid" do |app|
+      if defined?(Mongoid)
+        require 'groupify/adapter/mongoid'
+      end
+    end
+    
+  end
+end

data/lib/groupify/version.rb

@@ -1,3 +1,3 @@
 module Groupify
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/groupify.rb

@@ -1,197 +1,3 @@
 require 'active_support'
-require 'mongoid'
-require 'set'
 
-# Groups and members
-module Groupify
-  extend ActiveSupport::Concern
-  
-  included do
-    def none; where(:id => nil); end
-  end
-  
-  module ClassMethods
-    def acts_as_group(opts = {})
-      include Groupify::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 = {})
-      class_eval { @group_class_name = opts[:class_name] || 'Group' }
-      include Groupify::GroupMember
-    end
-    
-    def acts_as_named_group_member(opts = {})
-      include Groupify::NamedGroupMember
-    end
-  end
-
-  # Usage:
-  #    class Group
-  #        acts_as_group, :members => [:users]
-  #        ...
-  #    end
-  #
-  #   group.add(member)
-  #
-  module Group
-    extend ActiveSupport::Concern
-    
-    included do
-      @default_member_class = nil
-    end
-    
-    def members
-      self.class.default_member_class.any_in(:group_ids => [self.id])
-    end
-    
-    def add(member)
-      member.groups << self
-    end
-    
-    module ClassMethods
-      def with_member(member)
-        criteria.for_ids(member.group_ids)
-      end
-      
-      def default_member_class; @default_member_class || User; end
-      def default_member_class=(klass); @default_member_class = klass; end
-      
-      # Define which classes are members of this group
-      def has_members(name)
-        klass = name.to_s.classify.constantize
-        define_method name.to_s.pluralize.underscore do
-          klass.any_in(:group_ids => [self.id])
-        end
-      end
-    end
-  end
-  
-  # Usage:
-  #    class User
-  #        acts_as_group_member
-  #        ...
-  #    end
-  #
-  #    user.groups << group
-  #
-  module GroupMember
-    extend ActiveSupport::Concern
-    
-    included do
-      group_class_name='Group' unless defined?(@group_class_name)
-      has_and_belongs_to_many :groups, :autosave => true, :inverse_of => nil, :class_name => @group_class_name
-    end
-    
-    def in_group?(group)
-      self.groups.include?(group)
-    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? ? where(:group_ids.in => [group.id]) : none
-      end
-      
-      def in_any_group(*groups)
-        groups.present? ? where(:group_ids.in => groups.flatten.map{|g|g.id}) : none
-      end
-      
-      def in_all_groups(*groups)
-        groups.present? ? where(:group_ids => groups.flatten.map{|g|g.id}) : none
-      end
-      
-      def shares_any_group(other)
-        in_any_group(other.groups)
-      end
-      
-    end
-  end
-  
-  # Usage:
-  #    class User
-  #        acts_as_named_group_member
-  #        ...
-  #    end
-  #
-  #    user.named_groups << :admin
-  #
-  module NamedGroupMember
-    extend ActiveSupport::Concern
-    
-    included do
-      field :named_groups, :type => Array, :default => []
-      
-      before_save :uniq_named_groups
-      protected
-      def uniq_named_groups
-        named_groups.uniq!
-      end
-    end
-    
-    def in_named_group?(group)
-      self.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)
-    end
-    
-    module ClassMethods
-      def in_named_group(named_group)
-        named_group.present? ? where(:named_groups.in => [named_group]) : none
-      end
-      
-      def in_any_named_group(*named_groups)
-        named_groups.present? ? where(:named_groups.in => named_groups.flatten) : none
-      end
-      
-      def in_all_named_groups(*named_groups)
-        named_groups.present? ? where(:named_groups => named_groups.flatten) : none
-      end
-      
-      def shares_any_named_group(other)
-        in_any_named_group(other.named_groups)
-      end
-    end
-  end
-end
-
-Mongoid::Document.send :include, Groupify
+require 'groupify/railtie' if defined?(Rails)

data/spec/groupify/active_record_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+require 'active_record'
+
+# Load database config
+if JRUBY
+  require 'jdbc/sqlite3'
+  require 'active_record'
+  require 'active_record/connection_adapters/jdbcsqlite3_adapter'
+else
+  require 'sqlite3'
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner[:active_record].strategy = :transaction
+  end
+
+  config.before(:each) do
+    DatabaseCleaner[:active_record].start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner[:active_record].clean
+  end
+end
+
+ActiveRecord::Base.establish_connection( :adapter => 'sqlite3', :database => ":memory:" )
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define(:version => 1) do
+
+  create_table :groups do |t|
+    t.string     :name
+    t.string     :type
+  end
+  
+  create_table :group_memberships do |t|
+    t.string     :member_type
+    t.integer    :member_id
+    t.integer    :group_id
+    t.string     :group_name
+  end
+
+  create_table :users do |t|
+    t.string   :name
+    t.string   :type
+  end
+
+  create_table :widgets do |t|
+    t.string     :name
+  end
+
+  create_table :organizations do |t|
+    t.string     :name
+  end
+end
+
+require 'groupify'
+require 'groupify/adapter/active_record'
+
+class User < ActiveRecord::Base  
+  acts_as_group_member
+  acts_as_named_group_member
+end
+
+class Widget < ActiveRecord::Base
+  acts_as_group_member
+end
+
+class Group < ActiveRecord::Base  
+  acts_as_group :members => [:users, :widgets], :default_members => :users
+end
+
+class Manager < User
+end
+
+class Organization < Group
+  has_members :managers
+end
+
+class GroupMembership < ActiveRecord::Base  
+  acts_as_group_membership
+end
+
+describe Group do
+  it { should respond_to :members}
+  it { should respond_to :add }
+end
+
+describe User do
+  it { should respond_to :groups}
+  it { should respond_to :in_group?}
+  it { should respond_to :in_any_group?}
+  it { should respond_to :in_all_groups?}
+  it { should respond_to :shares_any_group?}
+end
+
+describe Groupify::ActiveRecord do
+  let(:user) { User.create! }
+  let(:group) { Group.create! }
+  let(:widget) { Widget.create! }
+  
+  it "adds a group to a member" do
+    user.groups << group
+    user.groups.should include(group)
+    group.members.should include(user)
+    group.users.should include(user)
+  end
+  
+  it "adds a member to a group" do
+    group.add user
+    user.groups.should include(group)
+    group.members.should include(user)
+  end
+
+  it 'lists which member classes can belong to this group' do
+    group.class.member_classes.should include(User, Widget)
+    group.member_classes.should include(User, Widget)
+    
+    Organization.member_classes.should include(User, Widget, Manager)
+  end
+  
+  it "finds members by group" do
+    group.add user
+    
+    User.in_group(group).first.should eql(user)
+  end
+
+  it "finds the group a member belongs to" do
+    group.add user
+    
+    Group.with_member(user).first.should == group
+  end
+
+  context 'when merging' do
+    let(:task) { Task.create! }
+    let(:manager) { Manager.create! }
+
+    it "moves the members from source to destination and destroys the source" do
+      source = Group.create!
+      destination = Organization.create!
+
+      source.add(user)
+      destination.add(manager)
+
+      destination.merge!(source)
+      source.destroyed?.should be_true
+      
+      destination.users.should include(user, manager)
+      destination.managers.should include(manager)
+    end
+
+    it "fails to merge if the destination group cannot contain the source group's members" do
+      source = Organization.create!
+      destination = Group.create!
+
+      source.add(manager)
+      destination.add(user)
+
+      # Managers cannot be members of a Group
+      expect {destination.merge!(source)}.to raise_error(ArgumentError)
+    end
+
+    it "merges incompatible groups as long as all the source members can be moved to the destination" do
+      source = Organization.create!
+      destination = Group.create!
+
+      source.add(user)
+      destination.add(widget)
+
+      expect {destination.merge!(source)}.to_not raise_error
+
+      source.destroyed?.should be_true
+      destination.users.to_a.should include(user)
+      destination.widgets.to_a.should include(widget)
+    end
+  end
+
+  it "members can belong to many groups" do
+    user.groups << group
+    group2 = Group.create!
+    user.groups << group2
+    
+    user.groups.should include(group)
+    user.groups.should include(group2)
+    
+    User.in_group(group).first.should eql(user)
+    User.in_group(group2).first.should eql(user)
+    
+    User.in_any_group(group).first.should eql(user)
+    User.in_all_groups(group, group2).first.should eql(user)
+    User.in_all_groups([group, group2]).first.should eql(user)
+  end
+  
+  it "members can have named groups" do
+    user.named_groups << :admin
+    user.named_groups << :user
+    user.save
+    user.named_groups.should include(:admin)
+    
+    user.in_named_group?(:admin).should be_true
+    user.in_any_named_group?(:admin, :user, :test).should be_true
+    user.in_all_named_groups?(:admin, :user).should be_true
+    user.in_all_named_groups?(:admin, :user, :test).should be_false
+
+    User.in_named_group(:admin).first.should eql(user)
+    User.in_any_named_group(:admin, :test).first.should eql(user)
+    User.in_all_named_groups(:admin, :user).first.should eql(user)
+    
+    # Uniqueness
+    user.named_groups << :admin
+    user.save
+    user.named_groups.count{|g| g == :admin}.should == 1
+  end
+  
+  it "members can check if groups are shared" do
+    user.groups << group
+    user2 = User.create!(:groups => [group])
+    
+    user.shares_any_group?(user2).should be_true
+    User.shares_any_group(user).to_a.should include(user2)
+  end
+  
+  it "members can check if named groups are shared" do
+    user.named_groups << :admin
+    user2 = User.create!(:named_groups => [:admin])
+    
+    user.shares_any_named_group?(user2).should be_true
+    User.shares_any_named_group(user).to_a.should include(user2)
+  end
+end