groupify 0.6.0.rc1 → 0.6.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 688ba7945e95997b9bd71d248d9c8d0e17da2663
-  data.tar.gz: 6e239d414dd7098a5d36e1517ac25827187ea55e
+  metadata.gz: 105996dc9352662d0363b74124dbb8f936b0d81b
+  data.tar.gz: 81479cdb755adba4da248918fcb891313279e772
 SHA512:
-  metadata.gz: a9e8494ba575bf48cf3b1c439aba5fbfd512e08a51d998c48a84ea10738cd43d409c8588e053391a5f4a8da50b683dba8bf9ae57907c262d71a40fb930d0377f
-  data.tar.gz: 2ee79e0d86e422250f1bc6859707ba439009eb5d8ef95e47998f87e492e983cce22bd7153703f8dc446f5688374e65e7a95bd364286ca3e0378febfe6829f14d
+  metadata.gz: 8fdd61ea3448ef18e8249c8680019ed21288c34c33738b695d660a1efaca29c3d55bb71ff9345f869d7d0d4086084092537fe0a183f2e963fb8aa62a92060315
+  data.tar.gz: 3c858406df76fe3cb960602e889bdd95cfde1d46c0addf5bbd70b03507e958a7d7448e0f79d42b7d65dbbc5b8665769af5ac284bfce18df35aad76d27fd244fe

data/.travis.yml

@@ -5,6 +5,7 @@ rvm:
   - 2.0.0
   - 2.1.0
   - 2.1.1
+  - 2.1.2
   - jruby-19mode
   - rbx-2
 gemfile:
@@ -13,4 +14,4 @@ gemfile:
   - gemfiles/rails_4.1.gemfile
 matrix:
   allow_failures:
-    - rvm: rbx-2
+    - rvm: rbx-2

data/Appraisals

@@ -5,20 +5,11 @@ 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"
+  gem "mongoid", "~> 4.0"
 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"
+  gem "mongoid", "~> 4.0"
 end

data/README.md

@@ -1,5 +1,5 @@
 # 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)
+[![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)
 
 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

data/gemfiles/rails_4.0.gemfile

@@ -5,7 +5,7 @@ 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"
+gem "mongoid", "~> 4.0"
 
 group :development do
   gem "pry"

data/gemfiles/rails_4.1.gemfile

@@ -5,7 +5,7 @@ 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"
+gem "mongoid", "~> 4.0"
 
 group :development do
   gem "pry"

data/lib/groupify/adapter/active_record.rb

@@ -1,588 +1,14 @@
 require 'active_record'
 require 'set'
 
-# Groups and members
 module Groupify
   module ActiveRecord
-    module Adapter
-      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
+    require 'groupify/adapter/active_record/model'
 
-          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
-
-    # 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, 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
-
-    # 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
-
-    # 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
-
-    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
-
-    
-    # Usage:
-    #    class User < ActiveRecord::Base
-    #        acts_as_named_group_member
-    #        ...
-    #    end
-    #
-    #    user.named_groups << :admin
-    #
-    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=(groups)
-        groups.each do |group|
-          self.named_groups << group
-        end
-      end
-      
-      def in_named_group?(named_group, opts={})
-        named_groups.include?(named_group, opts)
-      end
-      
-      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?(*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, 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)
-          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.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)
-          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)
-          in_any_named_group(other.named_groups.to_a)
-        end
-      end
-    end
+    autoload :Group, 'groupify/adapter/active_record/group'
+    autoload :GroupMember, 'groupify/adapter/active_record/group_member'
+    autoload :GroupMembership, 'groupify/adapter/active_record/group_membership'
+    autoload :NamedGroupCollection, 'groupify/adapter/active_record/named_group_collection'
+    autoload :NamedGroupMember, 'groupify/adapter/active_record/named_group_member'
   end
 end
-
-ActiveRecord::Base.send :include, Groupify::ActiveRecord::Adapter