acts_as_joinable 1.1.0 → 1.3.1

data/app/models/default_permission_set.rb

@@ -2,6 +2,7 @@ class DefaultPermissionSet < ActiveRecord::Base
   include Joinable::PermissionsAttributeWrapper
     
 	belongs_to :joinable, :polymorphic => true
+  has_many :permission_links, lambda { where("#{PermissionLink.table_name}.joinable_type = #{table_name}.joinable_type") }, :primary_key => :joinable_id, :foreign_key => :joinable_id
 
   after_update :raise_existing_member_permissions
   
@@ -15,6 +16,7 @@ class DefaultPermissionSet < ActiveRecord::Base
     end
   end
   
+  # Easy way to choose basic permission sets
   def access_model=(model)
     case model.to_s
     when 'open'

data/app/models/membership.rb

@@ -3,6 +3,7 @@ class Membership < ActiveRecord::Base
 
   belongs_to :joinable, :polymorphic => true
   belongs_to :user
+  has_many :permission_links, lambda { where("#{PermissionLink.table_name}.joinable_type = #{table_name}.joinable_type") }, :primary_key => :joinable_id, :foreign_key => :joinable_id
 
   before_save :prevent_locked_permission_changes, :normalize_owner_permissions
 

data/lib/acts_as_joinable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsJoinable
+  VERSION = "0.0.1"
+end

data/lib/acts_as_joinable.rb

@@ -1,6 +1,3 @@
-# GEM DEPENDENCIES
-require 'postgres_ext'
-
 require 'joinable/acts_as_permissable'
 require 'joinable/acts_as_joinable'
 require 'joinable/acts_as_joinable_component'

data/lib/joinable/acts_as_joinable.rb

@@ -8,20 +8,20 @@ module Joinable #:nodoc:
       # These unpacked permissions are put into an array with the singular permissions (eg. find)
       # and stored in a *permissions* class variable.
       #
-      # In addition, The grouped permissions are stored in a separate *component_permissions_hashes* class variable.
+      # In addition, The grouped permissions are stored in a separate *component_permissions_hash* class variable.
       # 
       # NOTE: The permissions are passed in-order because in the view we expect to find certain permission patterns.
       #       eg. the simple project permission level is determined by looking for a string of permissions that span
       #       several components, (labels, writeboards, files, etc...).
       # TODO: Remove the aforementioned order dependency      
       def acts_as_joinable(options = {})
-        extend ClassMethods unless (class << self; included_modules; end).include?(ClassMethods)
-        include InstanceMethods unless included_modules.include?(InstanceMethods)
+        extend ClassMethods
+        include InstanceMethods
 
         options.assert_valid_keys :component_permissions
-			  self.component_permissions_hashes = options[:component_permissions]
+        self.component_permissions_hash = options[:component_permissions]
 
-			  self.permissions = [:find, :view]
+        self.permissions = [:find, :view]
         add_flattened_component_permissions(options[:component_permissions])
         self.permissions += [:manage, :own]
       end
@@ -34,12 +34,10 @@ module Joinable #:nodoc:
       # eg. {:labels => [:view, :apply, :remove, :create, :delete]} becomes
       #      [:view_labels, :apply_labels, :remove_labels, :create_labels, :delete_labels]
       #      and is added to self.permissions
-      def add_flattened_component_permissions(component_permissions_hashes)
-        for component_permissions_hash in component_permissions_hashes
-  		    component_permissions_hash.each do |component_name, component_permissions|
-            component_permissions.each { |component_permission| self.permissions << "#{component_permission}_#{component_name}".to_sym }
-  		    end
-		    end
+      def add_flattened_component_permissions(component_permissions_hash)
+        component_permissions_hash.each do |component_name, component_permissions|
+          component_permissions.each { |component_permission| self.permissions << "#{component_permission}_#{component_name}".to_sym }
+        end
       end
     end
 
@@ -47,38 +45,28 @@ module Joinable #:nodoc:
       include Joinable::ActsAsPermissable::ClassMethods
 
       def self.extended(base)
-        base.cattr_accessor :permissions, :component_permissions_hashes
-
-        base.has_many :membership_invitations, :as => :joinable, :dependent => :destroy, :before_add => :add_initiator
-  		  base.has_many :membership_requests, :as => :joinable, :dependent => :destroy
-  			base.has_many :memberships, :as => :joinable, :dependent => :destroy, :order => "id ASC", :before_remove => :add_initiator
-
-  			base.has_many :invitees, :class_name => "User", :through => :membership_invitations, :source => :user
-  		  base.has_many :requestees, :class_name => "User", :through => :membership_requests, :source => :user
-  		  base.has_many :members, :class_name => "User", :through => :memberships, :source => :user
-
-  			base.has_many :non_owner_memberships, :as => :joinable, :class_name => 'Membership', :conditions => "permissions NOT LIKE '%own%'"
-        base.has_one :owner_membership, :as => :joinable, :class_name => 'Membership', :conditions => "permissions LIKE '%own%'"
-
-  			base.has_many :permission_links, :as => :joinable, :dependent => :destroy
+        base.class_eval do
+          cattr_accessor :permissions, :component_permissions_hash
 
-  			base.has_one :default_permission_set, :as => :joinable, :dependent => :destroy
+          has_many :membership_invitations,   :as => :joinable, :dependent => :destroy, :before_add => :add_initiator
+          has_many :membership_requests,      :as => :joinable, :dependent => :destroy
+          has_many :memberships,              lambda { order :id }, :as => :joinable, :dependent => :destroy, :before_remove => :add_initiator
 
-  			base.after_create :add_owner_membership
+          has_many :invitees,                 :class_name => "User", :through => :membership_invitations, :source => :user
+          has_many :requestees,               :class_name => "User", :through => :membership_requests, :source => :user
+          has_many :members,                  :class_name => "User", :through => :memberships, :source => :user
 
-        base.class_eval do
-          # Return all *joinables* that a User is a member of with the appropriate permissions
-          scope :with_permission, lambda {|user, permission| where(with_permission_sql(user, permission)) }
+          has_many :permission_links,         :as => :joinable, :dependent => :destroy
+          has_one :default_permission_set,    :as => :joinable, :dependent => :destroy
+                  
+          scope :with_member,                 lambda {|user| joins(:memberships).where(:memberships => {:user_id => user}).order("memberships.created_at DESC") }
 
-          #scope :open, lambda { where(default_permission_set_permission_exists_sql(joinable_type, joinable_id, 'find')) }
+          accepts_nested_attributes_for :default_permission_set
+          accepts_nested_attributes_for :membership_invitations, :allow_destroy => true
+          accepts_nested_attributes_for :memberships, :allow_destroy => true, :reject_if => proc { |attributes| attributes['locked'] == 'true' }
 
-          # TODO: Why is this NULLS LAST? Probably because we want the results in some specific order when joined with users, but couldn't we order manually in the find?
-          scope :with_member, lambda {|user| joins(:memberships).where(:memberships => {:user_id => (user.is_a?(User) ? user.id : user)}).order("memberships.created_at DESC NULLS LAST") }
+          after_create :add_owner_membership
         end
-
-        base.accepts_nested_attributes_for :default_permission_set
-        base.accepts_nested_attributes_for :membership_invitations, :allow_destroy => true
-        base.accepts_nested_attributes_for :memberships, :allow_destroy => true, :reject_if => proc { |attributes| attributes['locked'] == 'true' }
       end
 
       def permissions_string
@@ -141,36 +129,35 @@ module Joinable #:nodoc:
           user_id = user.id
         end
 
-        joinable_type = options[:type_column] || name
-        joinable_id = options[:id_column] || table_name + ".id"
+        joinable_id = options[:id_column] || "#{table_name}.id"
 
         if permission == :find
-          "#{membership_permission_exists_sql(user_id, joinable_type, joinable_id, 'find')} OR #{membership_invitation_permission_exists_sql(user_id, joinable_type, joinable_id, 'find')} OR #{default_permission_set_permission_exists_sql(joinable_type, joinable_id, 'find')}"
+          "#{membership_permission_exists_sql(user_id, joinable_id, 'find')} OR #{membership_invitation_permission_exists_sql(user_id, joinable_id, 'find')} OR #{default_permission_set_permission_exists_sql(joinable_id, 'find')}"
         elsif permission.to_s.starts_with?('view')
-          "#{membership_permission_exists_sql(user_id, joinable_type, joinable_id, permission)} OR #{default_permission_set_permission_exists_sql(joinable_type, joinable_id, permission)}"
+          "#{membership_permission_exists_sql(user_id, joinable_id, permission)} OR #{default_permission_set_permission_exists_sql(joinable_id, permission)}"
         elsif permission == :join
-          "#{membership_invitation_permission_exists_sql(user_id, joinable_type, joinable_id, 'view')} OR #{default_permission_set_permission_exists_sql(joinable_type, joinable_id, 'view')}"
+          "#{membership_invitation_permission_exists_sql(user_id, joinable_id, 'view')} OR #{default_permission_set_permission_exists_sql(joinable_id, 'view')}"
         elsif permission.to_s.starts_with?('join_and_')
-          default_permission_set_permission_exists_sql(joinable_type, joinable_id, permission.to_s.gsub('join_and_', ''))
+          default_permission_set_permission_exists_sql(joinable_id, permission.to_s.gsub('join_and_', ''))
         elsif permission == :collaborate
-          "EXISTS (SELECT id FROM memberships WHERE memberships.joinable_type = '#{joinable_type}' AND memberships.joinable_id = #{joinable_id} AND memberships.user_id = #{user_id} AND memberships.permissions && '{#{(collaborator_permissions - viewer_permissions).join(",")}}')"
+          "EXISTS (SELECT id FROM memberships WHERE memberships.joinable_type = '#{self.name}' AND memberships.joinable_id = #{joinable_id} AND memberships.user_id = #{user_id} AND memberships.permissions && '{#{(collaborator_permissions - viewer_permissions).join(",")}}')"
         else
-          membership_permission_exists_sql(user_id, joinable_type, joinable_id, permission)
+          membership_permission_exists_sql(user_id, joinable_id, permission)
         end
       end
 
       private
 
-      def membership_permission_exists_sql(user_id, joinable_type, joinable_id, permission)
-        "EXISTS (SELECT id FROM memberships WHERE memberships.joinable_type = '#{joinable_type}' AND memberships.joinable_id = #{joinable_id} AND memberships.user_id = #{user_id} AND #{permission_sql_condition('memberships.permissions', permission)})"
+      def membership_permission_exists_sql(user_id, joinable_id, permission)
+        "EXISTS (SELECT id FROM memberships WHERE memberships.joinable_type = '#{self.name}' AND memberships.joinable_id = #{joinable_id} AND memberships.user_id = #{user_id} AND #{permission_sql_condition('memberships.permissions', permission)})"
       end
 
-      def membership_invitation_permission_exists_sql(user_id, joinable_type, joinable_id, permission)
-        "EXISTS (SELECT id FROM membership_invitations WHERE membership_invitations.joinable_type = '#{joinable_type}' AND membership_invitations.joinable_id = #{joinable_id} AND membership_invitations.user_id = #{user_id} AND #{permission_sql_condition('membership_invitations.permissions', permission)})"
+      def membership_invitation_permission_exists_sql(user_id, joinable_id, permission)
+        "EXISTS (SELECT id FROM membership_invitations WHERE membership_invitations.joinable_type = '#{self.name}' AND membership_invitations.joinable_id = #{joinable_id} AND membership_invitations.user_id = #{user_id} AND #{permission_sql_condition('membership_invitations.permissions', permission)})"
       end
 
-      def default_permission_set_permission_exists_sql(joinable_type, joinable_id, permission)
-        "EXISTS (SELECT id FROM default_permission_sets WHERE default_permission_sets.joinable_type = '#{joinable_type}' AND default_permission_sets.joinable_id = #{joinable_id} AND #{permission_sql_condition('default_permission_sets.permissions', permission)})"
+      def default_permission_set_permission_exists_sql(joinable_id, permission)
+        "EXISTS (SELECT id FROM default_permission_sets WHERE default_permission_sets.joinable_type = '#{self.name}' AND default_permission_sets.joinable_id = #{joinable_id} AND #{permission_sql_condition('default_permission_sets.permissions', permission)})"
       end
     end
 
@@ -241,28 +228,35 @@ module Joinable #:nodoc:
       # user. This method also supports caching of a membership
       # request in order to facilitate eager loading.
       #NOTE: See :membership_request_for documentation for an in depth example of this type of behaviour
-      def membership_for(user)
+      def membership_for(user_id)
         if cached_membership != nil
           cached_membership
         else
-          memberships.where(:user_id => user.id).first
+          memberships.where(:user_id => user_id).first
         end
       end
 
       # Find out whether this Joinable has a membership for a certain user and return true, else false
-      def membership_for?(user)
-        !membership_for(user).nil?
+      def membership_for?(user_id)
+        !membership_for(user_id).nil?
       end
 
-      # Returns the timestamp of the last time the memberships were updated for this joinable
-      def memberships_updated_at
-        memberships.maximum(:updated_at)
+      # Returns a unique cache key any time the memberships were updated for this joinable
+      def memberships_cache_key
+        "#{memberships.size}_#{memberships.maximum(:updated_at).to_f}"
       end
 
-      delegate :access_model, :to => :default_permission_set
+      # Convenience method for reading or writing the default permission set's access_model
+      delegate :access_model, 'access_model=', :to => :default_permission_set
+
+      # Convenience method for reading the default permission set's access_model
+      def default_permissions
+        self.default_permission_set.permissions
+      end
 
-      def access_model=(model)
-        default_permission_set.access_model = model
+      # Convenience method for writing the default permission set's access_model
+      def default_permissions=(permissions)
+        self.default_permission_set.permissions = permissions
       end
 
       # Returns true or false depending on whether or not the user has the specified permission for this object.
@@ -287,8 +281,8 @@ module Joinable #:nodoc:
 
         cache_path = "permissions/#{self.class.table_name}/#{self.id}/user_#{user.id}_#{key}"
 
-        if defined?(RAILS_CACHE)
-          permissions = RAILS_CACHE.read(cache_path)
+        if defined?(Rails.cache)
+          permissions = Rails.cache.read(cache_path)
           if permissions && (value = permissions[permission_name]) != nil
             return value
           end
@@ -297,18 +291,23 @@ module Joinable #:nodoc:
         # The permission isn't cached yet, so cache it
         value = self.class.with_permission(user, permission_name).exists?(self.id)
 
-        if defined?(RAILS_CACHE)
+        if defined?(Rails.cache)
           if permissions
             permissions = permissions.dup
             permissions[permission_name] = value
           else
             permissions = {permission_name => value}
           end
-          RAILS_CACHE.write(cache_path, permissions)
+          Rails.cache.write(cache_path, permissions)
         end
         return value
       end
 
+      # Ensure the joinable has a set of default permissions (an empty set unless one already exists)
+      def default_permission_set
+        super || self.build_default_permission_set
+      end
+
       private
 
       # Adds an initiator to a membership or invitation to possibly use in feed generation
@@ -318,9 +317,8 @@ module Joinable #:nodoc:
 
       # Adds an permission entry with full access to the object by the user associated with the object if one does not already exist
       def add_owner_membership
-       Membership.create(:joinable => self, :user => user, :permissions => self.class.permissions_string) unless Membership.where(:joinable_type => self.class.to_s, :joinable_id => self.id, :user_id => user.id).exists?
+       Membership.where(:joinable => self, :user => user).first_or_create!(:permissions => self.class.permissions_string)
       end
     end
   end
-end
-
+end

data/lib/joinable/acts_as_joinable_component.rb

@@ -46,10 +46,6 @@ module Joinable #:nodoc:
       def self.extended(base)        
         base.has_one :permission_link, :as => :component, :dependent => :destroy
         base.after_create :find_joinable_and_create_permission_link
-
-        base.class_eval do
-          scope :with_permission, lambda { |user, permission| select("#{table_name}.*").where(with_permission_sql(user, permission)) }
-        end
       end
   
       # Returns the SQL necessary to find all components for which there is no associated joinable or 
@@ -72,49 +68,50 @@ module Joinable #:nodoc:
           user_id = user.id
         end
     
-        component_type = options[:type_column] || name
-        component_id = options[:id_column] || table_name + ".id"
+        component_id_column = options[:id_column] || "#{table_name}.id"
 
         permission_without_join_and_prefix = permission.gsub('join_and_', '')
-        comparison_permission = permission_without_join_and_prefix == 'view' ? "permission_links.component_view_permission" : "'#{permission_without_join_and_prefix}'"
+        permission_or_column = permission_without_join_and_prefix == 'view' ? "permission_links.component_view_permission" : "'#{permission_without_join_and_prefix}'"
 
         if permission.starts_with?('view')
-          "#{no_inherited_permissions_exist_sql(component_type, component_id)} OR #{membership_permission_exists_sql(user_id, component_type, component_id, comparison_permission)} OR #{default_permission_set_permission_exists_sql(component_type, component_id, comparison_permission)}"
+          "#{no_inherited_permissions_exist_sql(component_id_column)} OR #{membership_permission_exists_sql(user_id, component_id_column, permission_or_column)} OR #{default_permission_set_permission_exists_sql(component_id_column, permission_or_column)}"
         elsif permission.starts_with?('join_and_')
-          default_permission_set_permission_exists_sql(component_type, component_id, comparison_permission)
+          default_permission_set_permission_exists_sql(component_id_column, permission_or_column)
         else
-          "#{no_inherited_permissions_exist_sql(component_type, component_id)} OR #{membership_permission_exists_sql(user_id, component_type, component_id, comparison_permission)}"
+          "#{no_inherited_permissions_exist_sql(component_id_column)} OR #{membership_permission_exists_sql(user_id, component_id_column, permission_or_column)}"
         end
       end
   
       private
   
       # All components that don't have a permission link to a joinable
-      def no_inherited_permissions_exist_sql(component_type, component_id)
-        "NOT EXISTS (SELECT * FROM permission_links WHERE permission_links.component_type = '#{component_type}' AND permission_links.component_id = #{component_id})"
+      def no_inherited_permissions_exist_sql(component_id_column)
+        permission_links_for_joinable = PermissionLink.where(:component_type => self.name).where("permission_links.component_id = #{component_id_column}")
+
+        return "NOT EXISTS (#{ permission_links_for_joinable.to_sql })"
       end
   
       # All components that have an associated membership with a specific permission
       #
       # The view permission requires special handling because it may be customized in the permission_link.
       # For more information see the *recurse_to_inherit_custom_view_permission* method.
-      def membership_permission_exists_sql(user_id, component_type, component_id, comparison_permission)
-        "EXISTS (SELECT * FROM memberships 
-                               INNER JOIN permission_links ON memberships.joinable_type = permission_links.joinable_type
-                                    AND memberships.joinable_id = permission_links.joinable_id 
-                          WHERE permission_links.component_type = '#{component_type}' 
-                                AND permission_links.component_id = #{component_id} 
-                                AND memberships.user_id = #{user_id} 
-                                AND #{comparison_permission} = ANY(memberships.permissions))"
+      def membership_permission_exists_sql(user_id, component_id_column, permission_or_column)
+        memberships_allowing_permission = Membership.joins(:permission_links)
+          .where(:user_id => user_id)
+          .where("permission_links.component_type" => self.name)
+          .where("permission_links.component_id = #{component_id_column}")
+          .where(permission_sql_condition('memberships.permissions', permission_or_column, :raw => true))
+        
+        return "EXISTS (#{ memberships_allowing_permission.to_sql })"
       end
 
-      def default_permission_set_permission_exists_sql(component_type, component_id, comparison_permission)
-        "EXISTS (SELECT * FROM default_permission_sets
-                                 INNER JOIN permission_links ON default_permission_sets.joinable_type = permission_links.joinable_type
-                                      AND default_permission_sets.joinable_id = permission_links.joinable_id
-                            WHERE permission_links.component_type = '#{component_type}'
-                                  AND permission_links.component_id = #{component_id}
-                                  AND #{comparison_permission} = ANY(default_permission_sets.permissions))"
+      def default_permission_set_permission_exists_sql(component_id_column, permission_or_column)
+        sets_allowing_permission = DefaultPermissionSet.joins(:permission_links)
+          .where("permission_links.component_type" => self.name)
+          .where("permission_links.component_id = #{component_id_column}")
+          .where(permission_sql_condition('default_permission_sets.permissions', permission_or_column, :raw => true))
+
+        return "EXISTS (#{ sets_allowing_permission.to_sql })"
       end
     end
 
@@ -130,11 +127,9 @@ module Joinable #:nodoc:
       # Useful for outputting information to the user while they 
       # are creating a new component.
       def who_will_be_able_to_view?
-        User.find_by_sql("SELECT users.* 
-                          FROM users JOIN memberships ON users.id = memberships.user_id 
-                          WHERE memberships.joinable_type = '#{joinable.class.to_s}' 
-                          AND memberships.joinable_id = #{joinable.id} 
-                          AND #{self.class.permission_sql_condition('memberships.permissions', recurse_to_inherit_custom_view_permission)}")
+        User.joins(:memberships)
+          .where(:memberships => {:joinable => joinable})
+          .where(permission_sql_condition('memberships.permissions', recurse_to_inherit_custom_view_permission))
       end
 
       def check_permission(user, permission)
@@ -196,6 +191,7 @@ module Joinable #:nodoc:
       end
       attr_writer :view_permission
 
+      private
 
       # Recurse up the tree to see if any of the intervening joinable_components have a customized view permission
       # In that case, inherit that customized view permission. This allows searches of the form
@@ -208,7 +204,7 @@ module Joinable #:nodoc:
         if parent.acts_like?(:joinable) || self.view_permission
           return self.view_permission || :view
         elsif parent.acts_like?(:joinable_component)
-          return parent.recurse_to_inherit_custom_view_permission
+          return parent.send(:recurse_to_inherit_custom_view_permission)
         else
           return nil
         end

data/lib/joinable/acts_as_permissable.rb

@@ -10,9 +10,22 @@ module Joinable #:nodoc:
   		  return record
   		end
   		
-  		def permission_sql_condition(column, permission)
-  		  "'#{permission}' = ANY(#{column})"
-		  end
+      # Returns all records where the given user has the given permission
+      def with_permission(user, permission)
+        where(with_permission_sql(user, permission))
+      end
+
+      # Returns an SQL fragment for a WHERE condition that evaluates to true if the user has the given permission
+      # For use when asking 
+      def with_permission_sql(user, permission, options = {})
+        raise NotImplementedError
+      end
+
+      # Returns an SQL fragment for a WHERE condition that checks the given column for the given permission
+      def permission_sql_condition(column, permission, options = {})
+        permission = "'#{permission}'" unless options[:raw]
+        "#{permission} = ANY(#{column})"
+      end
     end
 
     module InstanceMethods
@@ -22,8 +35,10 @@ module Joinable #:nodoc:
     
       # Returns a list of users who either do or do not have the specified permission.
       def who_can?(permission)
-        User.find_by_sql("SELECT * FROM users AS u1 WHERE #{self.class.with_permission_sql('u1.id', permission, :id_column => id)}")
+        User.where(with_permission_sql("#{User.table_name}.id", permission, :id_column => id))
       end
+
+      delegate :with_permission_sql, :permission_sql_condition, :to => 'self.class'
     end
   end
 end

data/lib/joinable/feedable_extensions.rb

@@ -2,12 +2,14 @@ module FeedableExtensions
   def self.add
     Feed.class_eval do
       # Filter feeds about public joinables that you haven't joined, unless the feed is actually about you
-      scope :without_unjoined, lambda {|joinable_type, user| 
+      scope :not_from_unjoined, lambda {|joinable_type, user| 
         where("feeds.scoping_object_type IS NULL OR
                feeds.scoping_object_type != '#{joinable_type}' OR
                (feeds.feedable_type = 'User' AND feeds.feedable_id = #{user.id}) OR
                EXISTS (SELECT * FROM memberships WHERE memberships.joinable_type = '#{joinable_type}' AND memberships.joinable_id = feeds.scoping_object_id AND memberships.user_id = ?)", user.id)
       }
+      # Filter feeds about public things where the given action took place
+      scope :not_unscoped, lambda {|action| where('NOT (feeds.scoping_object_type IS NULL AND feeds.action = ?)', action) }
 
       acts_as_joinable_component :parent => 'permission_inheritance_target', :polymorphic => true, :view_permission => lambda {|feed| :find if feed.feedable.acts_like?(:joinable) }
       

data/lib/joinable/permissions_attribute_wrapper.rb

@@ -14,13 +14,13 @@ module Joinable #:nodoc:
   
     # Returns an array of the permissions as symbols
     def permissions
-      self[:permissions].collect(&:to_sym)
+      Array.wrap(self[:permissions]).collect(&:to_sym)
     end
   
     def permissions=(permissions)
       case permissions
-      when String
-        self[:permissions] = permissions.split(' ')
+      when String, Symbol
+        self[:permissions] = permissions.to_s.split(' ')
       when Array
         self[:permissions] = permissions
       else
@@ -98,6 +98,31 @@ module Joinable #:nodoc:
       self.permissions += permissions_to_grant
     end
   
+    # Adds readers for component permission groups and single permissions
+    #
+    # Used by advanced permission forms to determine how which options to select
+    # in the various fields. (eg. which option of f.select :labels_permissions to choose)
+    def method_missing(method_name, *args, &block)      
+      # NOTE: As of Rails 4, respond_to? must be checked inside the case statement otherwise it breaks regular AR attribute accessors
+      case method_name.to_s
+      when /.+_permissions/
+        return component_permissions_reader(method_name) if respond_to?(:joinable_type) && joinable_type.present?
+      when /.+_permission/
+        return single_permission_reader(method_name) if respond_to?(:joinable_type) && joinable_type.present?
+      end
+
+      super
+    end
+
+    def respond_to?(method_name, include_private = false)
+      case method_name.to_s
+      when /.+_permissions?/
+        return true if respond_to?(:joinable_type) && joinable_type.present?
+      end
+
+      super
+    end    
+
     private
   
     # Verifies that all the access levels are valid for the attached permissible
@@ -112,37 +137,12 @@ module Joinable #:nodoc:
       self.permissions = permissions.uniq.sort_by { |permission| allowed_permissions.index(permission) }
     end
   
-    # Adds readers for component permission groups and single permissions
-    #
-    # Used by advanced permission forms to determine how which options to select
-    # in the various fields. (eg. which option of f.select :labels_permissions to choose)
-    def method_missing(method_name, *args)
-      # add permission_for accessors and mutators
-    
-      # NOTE: Don't mess with the method_name variable (e.g. change it to a string)
-      # since upstream methods might assume it is a symbol.
-      # NOTE: Ensure we enforce some characters before the '_permission' suffix because Rails 3 creates 
-      if respond_to?(:joinable_type) && joinable_type.present?
-        if method_name.to_s =~ /.+_permissions/
-          return component_permissions_reader(method_name)
-        elsif method_name.to_s =~ /.+_permission/
-          return single_permission_reader(method_name)
-        else
-          super
-        end
-      else
-        super
-      end
-    end
-  
     # Get a string of all of the permissions the object has for a specific joinable component
     # eg. labels_permissions # returns 'view_labels apply_labels remove_labels'
     def component_permissions_reader(method_name)
-      for component_permissions_hash in joinable_type.constantize.component_permissions_hashes
-        component_permissions_hash.each do |component_name, component_permissions|
-          if method_name.to_s == "#{component_name}_permissions"
-            return component_permissions.collect {|permission| "#{permission}_#{component_name}"}.select {|permission| has_permission?(permission)}.join(" ")
-          end
+      joinable_type.constantize.component_permissions_hash.each do |component_name, component_permissions|
+        if method_name.to_s == "#{component_name}_permissions"
+          return component_permissions.collect {|permission| "#{permission}_#{component_name}"}.select {|permission| has_permission?(permission)}.join(" ")
         end
       end
     

data/lib/tasks/acts_as_joinable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :acts_as_joinable do
+#   # Task goes here
+# end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: acts_as_joinable
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.1
   prerelease: 
 platform: ruby
 authors:
@@ -10,16 +10,32 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-30 00:00:00.000000000 Z
+date: 2013-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: postgres_ext
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,7 +43,23 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Adds access control to objects by giving them members, each with configurable
   permissions.
 email: technical@rrnpilot.org
@@ -40,6 +72,7 @@ files:
 - app/models/membership_invitation.rb
 - app/models/membership_request.rb
 - app/models/permission_link.rb
+- lib/acts_as_joinable/version.rb
 - lib/acts_as_joinable.rb
 - lib/joinable/acts_as_joinable.rb
 - lib/joinable/acts_as_joinable_component.rb
@@ -47,6 +80,7 @@ files:
 - lib/joinable/acts_as_permissable.rb
 - lib/joinable/feedable_extensions.rb
 - lib/joinable/permissions_attribute_wrapper.rb
+- lib/tasks/acts_as_joinable_tasks.rake
 - README.rdoc
 homepage: http://github.com/rrn/acts_as_joinable
 licenses: []
@@ -57,13 +91,13 @@ require_paths:
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []