radiant-reader_group-extension 1.1.2 → 1.2.0

data/README.markdown

@@ -1,17 +1,21 @@
 # Reader Group Extension
 
-The basic purpose of this extension is to control access to pages in your public site. It allows you to create a group of readers, and to make pages 9and other site elements) visible only to selected groups. It also provides a useful - and now quite shiny - group-messaging interface and a batch-import function for inviting readers.
+The basic purpose of this extension is to control access to pages in your public site. It allows you to create a group of readers, and to make pages visible only to selected groups. It also provides a useful group-messaging interface using the reader extensions html-mailer and a batch-import function for inviting people into your groups.
 
-In combination with our other extensions it also lets you control access to forums, downloads and assets. I hope other people will find the framework useful and apply it to their own requirements.
+In combination with our other extensions it also lets you control access to forums, downloads and assets. I hope other people will find the framework useful and apply it to their own requirements. Any resource class can be given group-based access control with a single call:
 
-This extension doesn't group your users or affect the admin interface at all, apart from adding (quite a lot of) machinery for looking after groups. As always, readers have their own self-management interface that looks like the rest of your site. They never see the admin pages.
+	class Widget << ActiveRecord::Base
+	  has_groups
+	end
 
-This works with multi_site. If you use [our fork](https://github.com/spanner/radiant-paperclipped_multisite-extension/tree) then readers and groups are automatically site-scoped.
+This extension doesn't group your users or affect the admin interface in any way, apart from adding (quite a lot of) machinery for looking after groups and their messages. As always, readers have their own self-management interface that looks like the rest of your site. They never see the admin pages.
+
+This works with multi_site (but right now the reader extension doesn't, or not very well). If you use [our fork](https://github.com/spanner/radiant-paperclipped_multisite-extension/tree) then groups are automatically site-scoped.
 
 ## Latest
 
-* groups can be marked subscribable, which puts a checkbox to subscribe or unsubscribe on the readers' registration and preference forms. Migration required.
-* messages can each have a different layout
+* all group relations are now habtm, so that any object can have one or more groups. Objects with only one group behave as before. Some of the scopes are quite thickety now so there may be bugs in the corners. Migration required.
+* groups can be marked subscribable, which puts a checkbox to subscribe or unsubscribe on the readers' registration and preference forms.
 
 ## Status
 
@@ -19,12 +23,16 @@ This has been brought across from a previous version that grouped users instead
 
 ## Requirements
 
-Radiant 0.9.x and the [reader](https://github.com/spanner/radiant-reader-extension/tree) extension.
+Radiant 0.9.x and the [reader](https://github.com/spanner/radiant-reader-extension) extension.
 
 ## Installation
 
 Once you've got the reader extension in, the rest is easy:
 
+	gem install radiant-reader_group-extension
+
+or vendored:
+
 	git submodule add git://github.com/spanner/radiant-reader_group-extension.git vendor/extensions/reader_group
 	rake radiant:extensions:reader_group:migrate
 	rake radiant:extensions:reader_group:update
@@ -35,7 +43,7 @@ On github, please.
 
 ## Author and copyright
 
-* Copyright spanner ltd 2007-9.
+* Copyright spanner ltd 2007-11.
 * Released under the same terms as Rails and/or Radiant.
 * Contact will at spanner.org
 

data/VERSION

@@ -1 +1 @@
-1.1.2
+1.2.0

data/app/models/group.rb

@@ -19,7 +19,20 @@ class Group < ActiveRecord::Base
   named_scope :with_home_page, { :conditions => "homepage_id IS NOT NULL", :include => :homepage }
   named_scope :subscribable, { :conditions => "public = 1" }
   named_scope :unsubscribable, { :conditions => "public = 0" }
-  
+
+  named_scope :attached_to, lambda { |objects|
+    conditions = objects.map{|o| "(pp.permitted_type = ? AND pp.permitted_id = ?)" }.join(" OR ")
+    binds = objects.map{|o| [o.class.to_s, o.id]}.flatten
+    {
+      :select => "groups.*, count(pp.group_id) AS pcount",
+      :joins => "INNER JOIN permissions as pp on pp.group_id = groups.id", 
+      :conditions => [conditions, *binds],
+      :having => "pcount > 0",    # otherwise attached_to([]) returns all groups
+      :group => column_names.map { |n| self.table_name + '.' + n }.join(','),
+      :readonly => false
+    }
+  }
+
   def url
     homepage.url if homepage
   end
@@ -31,13 +44,32 @@ class Group < ActiveRecord::Base
     end
   end
 
-  def permission_for(page)
-    self.permissions.for(page).first
+  def admit(reader)
+    self.readers << reader
+  end
+
+  def permission_for(object)
+    self.permissions.for(object).first
   end
 
   def membership_for(reader)
     self.memberships.for(reader).first
   end
+  
+  # we can't has_many through the polymorphic permission relationship, so this is called from has_groups
+  # and for eg. Page, it defines:
+  # Permission.for_pages named_scope
+  # Group.page_permissions  => set of permission objects
+  # Group.pages             => set of page objects
+  
+  def self.define_retrieval_methods(classname)
+    type_scope = "for_#{classname.downcase.pluralize}".intern
+    Permission.send :named_scope, type_scope, :conditions => { :permitted_type => classname }
+    define_method("#{classname.downcase}_permissions") { self.permissions.send type_scope }
+    define_method("#{classname.downcase.pluralize}") { self.send("#{classname.to_s.downcase}_permissions".intern).map(&:permitted) }
+  end
+  
+  
 
 end
 

data/app/models/permission.rb

@@ -1,12 +1,10 @@
 class Permission < ActiveRecord::Base
 
   belongs_to :group
-  belongs_to :page
+  belongs_to :permitted, :polymorphic => true
   
-  named_scope :for, lambda { |page|
-    {
-      :conditions => ["permissions.page_id = ?", page.id]
-    }
+  named_scope :for, lambda { |object|
+    { :conditions => ["permissions.permitted_id = ? and permissions.permitted_type = ?", object.id, object.class.to_s] }
   }
   
 end

data/app/views/admin/messages/_function.haml

@@ -1,7 +1,14 @@
 - if @message.administrative?
   %p
     - if @message.group
-      = t("group_#{@message.function}_sent_automatically", :name => @message.group.name)
+      = t("group_#{@message.function}")
+      = t("sent_to_group")
+    - elsif @message.groups.any?
+      = t("group_#{@message.function}")
+      = t("sent_to_these_groups")
+      %ul
+        - @message.groups.each do |group|
+          %li= link_to group.name, admin_group_url(group)
     - else
       = t("#{@message.function}_sent_automatically")
   %ul
@@ -16,4 +23,9 @@
 - if @message.group
   %p
     = t("belongs_to_group", :name => @message.group.name)
-  
+- elsif @message.groups.any?
+  %p
+    = t("belongs_to_these_groups")
+  %ul
+    - @message.groups.each do |group|
+      %li= link_to group.name, admin_group_url(group)

data/config/locales/en.yml

@@ -19,6 +19,10 @@ en:
   private_page_explanation: "The pages selected on the left are only visible to the people selected on the right."
   group_welcome_sent_automatically: "This message is sent automatically when someone joins the %{name} group."
   group_invitation_sent_automatically: "This message is sent automatically when someone is invited into the %{name} group."
+  sent_to_group: "sent automatically to the %{name} group"
+  sent_to_these_groups: "sent automatically to these groups"
+  group_welcome: "This is the welcome message"
+  group_invitation: "This is the invitation message"
   all_in_group: "Everyone in the group"
   inactive_in_group: "Group members who have not activated their account"
   unsent_in_group: "Group members who have not received this message"
@@ -29,6 +33,7 @@ en:
   really_delete_group: "Are you sure you want to completely remove the '%{name}' group? This cannot be undone."
   edit_group: "edit group"
   belongs_to_group: "This message belongs to the %{name} group."
+  belongs_to_these_groups: "This message is sent to these groups:"
   invite_into_group: "Invite people into the %{name} group"
   invitation_instructions: "This is a quick way to bring a group of people into the system in one go. Enter a comma-separated list of names and email addresses (one person per line) and after a bit of checking and tweaking on the next page, each of those people will be invited into the system and issued an account with a vaguely adequate username and entirely random password. Anyone who is already here will just be added to the group."
   check_invitation_message: "Preview invitation message"

data/db/migrate/20110214101339_multiple_ownership.rb

@@ -0,0 +1,13 @@
+class MultipleOwnership < ActiveRecord::Migration
+  def self.up
+    rename_column :permissions, :page_id, :permitted_id
+    add_column :permissions, :permitted_type, :string
+    Permission.reset_column_information
+    Permission.all.each {|p| p.update_attributes(:permitted_type => 'Page') }
+  end
+
+  def self.down
+    rename_column :permissions, :permitted_id, :page_id
+    remove_column :permissions, :permitted_type
+  end
+end

data/lib/grouped_message.rb

@@ -2,30 +2,30 @@ module GroupedMessage
 
   def self.included(base)
     base.class_eval {
-      has_group
+      has_groups
 
       include InstanceMethods
-      alias_method_chain :possible_readers, :group
-      alias_method_chain :inactive_readers, :group
+      alias_method_chain :possible_readers, :groups
+      alias_method_chain :inactive_readers, :groups
       
       extend ClassMethods
       class << self
-        alias_method_chain :functional, :group
+        alias_method_chain :functional, :groups
       end
     }
   end
   
   module InstanceMethods
-    def possible_readers_with_group
-      group ? group.readers.active : possible_readers_without_group
+    def possible_readers_with_groups
+      groups.any? ? Reader.in_groups(groups).active : possible_readers_without_groups
     end
-    def inactive_readers_with_group
-      group ? group.readers.inactive : inactive_readers_without_group
+    def inactive_readers_with_groups
+      groups.any? ? Reader.in_groups(groups).inactive : inactive_readers_without_groups
     end
   end
   
   module ClassMethods
-    def functional_with_group(function, group=nil)
+    def functional_with_groups(function, group=nil)
       messages = for_function(function)
       if group
         messages.for_group(group).first

data/lib/grouped_model.rb

@@ -4,13 +4,13 @@ module GroupedModel
   end
 
   module ClassMethods
-    def has_group?
+    def has_groups?
       false
     end
+    alias :has_group? :has_groups?
     
-    def has_group(options={})
-      return if has_group?
-      cattr_accessor :group_recipients, :group_donor
+    def has_groups(options={})
+      return if has_groups?
       
       class_eval {
         extend GroupedModel::GroupedClassMethods
@@ -21,88 +21,97 @@ module GroupedModel
             return true
           end
         end
-
-        def visible_to_with_groups?(reader)
-          value_otherwise = visible_to_without_groups?(reader)
-          return value_otherwise unless group
-          return false unless reader
-          return value_otherwise if reader.is_in?(group)
-          return false
-        end
         alias_method_chain :visible_to?, :groups
       }
       
-      belongs_to :group
-      named_scope :ungrouped, {:conditions => 'group_id IS NULL'}
-      named_scope :for_group, lambda { |g| {:conditions => ["group_id = ?", g]} }
+      has_many :permissions, :as => :permitted
+      has_many :groups, :through => :permissions
+      accepts_nested_attributes_for :permissions
+      Group.define_retrieval_methods(self.to_s)
+
+      named_scope :ungrouped, {
+        :select => "#{self.table_name}.*, count(pp.id) as group_count",
+        :joins => "LEFT OUTER JOIN permissions as pp on pp.permitted_id = #{self.table_name}.id AND pp.permitted_type = '#{self.to_s}'", 
+        :having => "group_count = 0",
+        :group => column_names.map { |n| self.table_name + '.' + n }.join(','),    # postgres requires that we group by all selected (but not aggregated) columns
+        :readonly => false
+      }
+
+      named_scope :grouped, {
+        :select => "#{self.table_name}.*, count(pp.id) as group_count",
+        :joins => "LEFT OUTER JOIN permissions as pp on pp.permitted_id = #{self.table_name}.id AND pp.permitted_type = '#{self.to_s}'", 
+        :having => "group_count > 0",
+        :group => column_names.map { |n| self.table_name + '.' + n }.join(','),
+        :readonly => false
+      }
+      
+      named_scope :for_group, lambda { |group| 
+        {
+          :joins => "INNER JOIN permissions as pp on pp.permitted_id = #{self.table_name}.id AND pp.permitted_type = '#{self.to_s}'", 
+          :conditions => ["pp.group_id = ?)", group.id],
+          :group => column_names.map { |n| self.table_name + '.' + n }.join(','),
+          :readonly => false
+        }
+      }
+            
       named_scope :visible_to, lambda { |reader| 
         groups = reader.nil? ? [] : reader.groups
         {:conditions => ["group_id IS NULL OR group_id IN(?)", groups.map(&:id).join(',')]} 
       }
-      
-      Group.send(:has_many, self.to_s.pluralize.underscore.intern)
-
-      before_create :get_group
-      after_save :give_group
     end
-    alias :is_grouped :has_group
-    alias :is_grouped? :has_group?
+    alias :has_group :has_groups
   end
 
   module GroupedClassMethods
-    def has_group?
+    def has_groups?
       true
     end
     
     def visible
       ungrouped
     end
-    
-    def gets_group_from(association_name)
-      association = reflect_on_association(association_name)
-      raise StandardError "can't find group source '#{association_name}" unless association
-      raise StandardError "#{association.klass} is not grouped and cannot be a group donor" unless association.klass.has_group? 
-      self.group_donor = association_name
-    end
-    
-    def gives_group_to(associations)
-      associations = [associations] unless associations.is_a?(Array)
-      # shall we force has_group here?
-      # shall we assume that gets_group_from follows? and find the association somehow?
-      self.group_recipients ||= []
-      self.group_recipients += associations
-    end
   end
 
   module GroupedInstanceMethods
 
-    def visible?
-      !!group
-    end
-
+    # in GroupedPage this is chained to include inherited groups
     def permitted_groups
-      [group]
+      groups
     end
 
-  protected
+    def visible_to_with_groups?(reader)
+      return false unless visible_to_without_groups?(reader)
+      return true if self.permitted_groups.empty?
+      return false if reader.nil?
+      return true if reader.is_admin?
+      return (reader.groups & self.permitted_groups).any?
+    end
 
-    def get_group
-      if self.class.group_donor && group_source = self.send(self.class.group_donor)
-        self.group = group_source.group
+    def group
+      if self.permitted_groups.length == 1
+        self.permitted_groups.first
+      else
+        nil
       end
     end
+    
+    def visible?
+      permitted_groups.empty?
+    end
 
-    def give_group
-      if self.class.group_recipients
-        self.class.group_recipients.each do |association|
-          send(association).each do |associate|
-            unless associate.group == group
-              associate.group = group 
-              associate.save(false)
-            end
-          end
-        end
-      end
+    def permitted_readers
+      permitted_groups.any? ? Reader.in_groups(permitted_groups) : Reader.all
+    end
+    
+    # GroupedPage also defines a separate has_inherited_group? method
+    # so here we don't call permitted_groups
+    def has_group?(group)
+      return self.groups.include?(group)
     end
+    
+    def permit(group)
+      self.groups << group unless self.has_group?(group)
+    end
+
   end
 end

data/lib/grouped_page.rb

@@ -2,50 +2,39 @@ module GroupedPage
 
   def self.included(base)
     base.class_eval {
-      has_many :permissions
-      has_many :groups, :through => :permissions
-      accepts_nested_attributes_for :permissions
-      has_one :group, :foreign_key => 'homepage_id'
-      
+      has_groups
+      has_one :homegroup, :foreign_key => 'homepage_id', :class_name => 'Group'
       include InstanceMethods
-      
-      # any page with a group-marker is never cached
-      # so that we can continue to return cache hits without care
-      # this check is regrettably expensive
-
-      def cache?
-        self.inherited_groups.empty?
-      end        
+      alias_method_chain :permitted_groups, :inheritance
     }
   end
   
   module InstanceMethods
     
-    def visible_to?(reader)
-      permitted_groups = self.inherited_groups  
-      return true if permitted_groups.empty?
-      return false if reader.nil?
-      return true if reader.is_admin?
-      return reader.in_any_of_these_groups?(permitted_groups)
-    end
-
     # this is all very inefficient recursive stuff
-    # but to do it in one pass we'd have to build a list of pages anyway
-    # so there isn't much to gain unless we shift to a different kind of tree
+    # but the ancestor pages should be in memory already
+    # and the groups check is now a single query
 
     def inherited_groups
-      if (self.parent.nil?)
-        self.groups
+      lineage = self.ancestors
+      if lineage.any?
+        Group.attached_to(lineage)
       else
-        self.groups + self.parent.inherited_groups
+        []
       end
     end
-    alias permitted_groups inherited_groups
 
-    def has_group?(group)
-      return self.groups.include?(group)
+    def permitted_groups_with_inheritance
+      permitted_groups_without_inheritance + inherited_groups
     end
 
+    # any page with a group-marker is never cached
+    # so that we can return cache hits with confidence
+    # this call is regrettably expensive
+    def cache?
+      self.permitted_groups.empty?
+    end        
+
     def has_inherited_group?(group)
       return self.inherited_groups.include?(group)
     end

data/lib/grouped_reader.rb

@@ -9,6 +9,15 @@ module GroupedReader
       include InstanceMethods
       alias_method_chain :activate!, :group
       alias_method_chain :send_functional_message, :group
+      
+      named_scope :in_groups, lambda { |groups| 
+        {
+          :select => "readers.*",
+          :joins => "INNER JOIN memberships as mm on mm.reader_id = readers.id", 
+          :conditions => ["mm.group_id IN (#{groups.map{'?'}.join(',')})", *groups.map{|g| g.is_a?(Group) ? g.id : g}],
+          :group => "mm.reader_id"
+        }
+      }
     }
   end
 

data/lib/site_controller_extensions.rb

@@ -2,10 +2,8 @@ module SiteControllerExtensions
   
   def self.included(base)
     base.class_eval {
-      # to control access without ruining the cache we have set Page.cache? = false
-      # for any page that has a group association. This should  prevent the relatively 
-      # few private pages from being cached, and it remains safe to return any cached
-      # page we find.
+      # NB. to control access without disabling the cache we have overridden Page.cache? 
+      # to return false for any page that has a group association. 
       
       def find_page_with_group_check(url)
         page = find_page_without_group_check(url)
@@ -17,11 +15,11 @@ module SiteControllerExtensions
         show_page_without_group_check
       rescue ReaderGroup::PermissionDenied
         if current_reader
-          flash[:error] = "sorry_access_denied"
+          flash[:error] = t("access_denied")
           redirect_to reader_permission_denied_url
         else
-          flash[:explanation] = "page_not_public"
-          flash[:error] = "please_log_in"
+          flash[:explanation] = t("page_not_public")
+          flash[:error] = t("please_log_in")
           store_location
           redirect_to reader_login_url
         end

data/public/stylesheets/sass/admin/reader_group.sass

@@ -128,6 +128,8 @@
     background-image: url(/images/admin/chk_off.png)
   &.inherited
     background-image: url(/images/admin/chk_auto.png)
+  &.waiting
+    background-image: url(/images/admin/spinner.gif)
 
 .checked a, .selected a
   color: #5da454

data/radiant-reader_group-extension.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{radiant-reader_group-extension}
-  s.version = "1.1.2"
+  s.version = "1.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["spanner"]
-  s.date = %q{2011-02-11}
+  s.date = %q{2011-02-15}
   s.description = %q{Adds group-based page access control to radiant.}
   s.email = %q{will@spanner.org}
   s.extra_rdoc_files = [
@@ -55,6 +55,7 @@ Gem::Specification.new do |s|
      "db/migrate/001_create_groups.rb",
      "db/migrate/20090921125654_group_messages.rb",
      "db/migrate/20091120083119_groups_public.rb",
+     "db/migrate/20110214101339_multiple_ownership.rb",
      "lib/admin_messages_controller_extensions.rb",
      "lib/group_message_tags.rb",
      "lib/group_ui.rb",

data/spec/datasets/groups_dataset.rb

@@ -36,13 +36,19 @@ class GroupsDataset < Dataset::Base
   end
   
   def add_pages_to_group(g, pp)
-    g = g.is_a?(Group) ? g : groups(g)
-    g.pages << pp.map{|p| pages(p)}
+    g = groups(g) unless g.is_a? Group
+    pp.each {|p| 
+      p = pages(p) unless p.is_a? Page
+      p.permit(g)
+    }
   end
   
   def add_readers_to_group(g, rr)
-    g = g.is_a?(Group) ? g : groups(g)
-    g.readers <<  rr.map{|r| readers(r)}
+    g = groups(g) unless g.is_a? Group
+    rr.each {|r| 
+      r = readers(r) unless r.is_a? Reader
+      g.admit(r)
+    }
   end
   
 end

data/spec/models/group_spec.rb

@@ -32,12 +32,14 @@ describe Group do
 
   it "should have a group of readers" do
     group = groups(:normal)
+    group.respond_to?(:readers).should be_true
     group.readers.any?.should be_true
     group.readers.size.should == 2
   end
 
   it "should have a group of pages" do
     group = groups(:homed)
+    group.respond_to?(:pages).should be_true
     group.pages.any?.should be_true
     group.pages.size.should == 2
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: radiant-reader_group-extension
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 31
   prerelease: false
   segments: 
   - 1
-  - 1
   - 2
-  version: 1.1.2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - spanner
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-11 00:00:00 +00:00
+date: 2011-02-15 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -96,6 +96,7 @@ files:
 - db/migrate/001_create_groups.rb
 - db/migrate/20090921125654_group_messages.rb
 - db/migrate/20091120083119_groups_public.rb
+- db/migrate/20110214101339_multiple_ownership.rb
 - lib/admin_messages_controller_extensions.rb
 - lib/group_message_tags.rb
 - lib/group_ui.rb