rolify 0.4.0 → 0.5.0

data/CHANGELOG.rdoc

@@ -1,3 +1,11 @@
+= 0.5
+* dynamic shortcuts support
+  * creates automatically new methods upon new role creation (or at startup for a Rails app)
+  * <tt>has_role "admin"</tt> will create a method called <tt>is_admin?</tt>
+  * <tt>has_role "moderator", Forum.first</tt> will create 2 methods:
+     * <tt>is_moderator_of?(resource)</tt>
+     * <tt>is_moderator?</tt>
+
 = v0.4
 * removing role support
   * <tt>has_no_role</tt> removes a global role or a role scoped to a resource

data/README.rdoc

@@ -34,6 +34,7 @@ First, create your Role model and migration file using this generator:
 
 Role and User classes are the default. You can specify any Role class name you want. This is completly a new file so any name can do the job.
 For the User class name, you would probably use the one provided by your authentication solution. rolify just adds some class methods in an existing User class.
+<b>**For now, please stick to Role and User class names, see {#5}[https://github.com/EppO/rolify/issues/5] for details**</b>
 
 === 2. Run the migration
 
@@ -92,5 +93,4 @@ If you have any issue or feature request with/for rolify, please add an {issue o
 
 * put syntactic sugar:
   * <tt>is_admin?</tt> and <tt>is_admin_of?(resource)</tt> like shortcuts
-  * multiple role names query at the same time
 * write a tutorial showing how to use rolify with CanCan and devise

data/lib/generators/rolify/role/role_generator.rb

@@ -14,11 +14,14 @@ module Rolify
       def generate_role
         template "role.rb", "app/models/role.rb"
         inject_into_class(model_path, user_cname.camelize) do
-          "  include Rolify\n" + "  has_and_belongs_to_many :#{role_cname.tableize}\n"
+          "  include Rolify::Roles\n" + 
+          "  extend Rolify::Reloaded\n" + 
+          "  has_and_belongs_to_many :roles, :class_name => \"#{role_cname.camelize}\"\n"
         end
       end
 
       def copy_role_file
+        template "initializer.rb", "config/initializers/rolify.rb"
         migration_template "migration.rb", "db/migrate/rolify_create_#{role_cname.tableize}"
       end
 

data/lib/generators/rolify/role/templates/initializer.rb

@@ -0,0 +1 @@
+<%= user_cname.camelize %>.load_dynamic_methods

data/lib/rolify/role.rb

@@ -1,69 +1,100 @@
 module Rolify
-  def has_role(role_name, resource = nil)
-    role = Role.find_or_create_by_name_and_resource_type_and_resource_id( :name => role_name, 
-                                                                          :resource_type => (resource.class.name if resource), 
-                                                                          :resource_id => (resource.id if resource))
-    self.roles << role if !roles.include?(role)
-  end
+
+  module Roles
+
+    def has_role(role_name, resource = nil)
+      role = Role.find_or_create_by_name_and_resource_type_and_resource_id( :name => role_name, 
+                                                                            :resource_type => (resource.class.name if resource), 
+                                                                            :resource_id => (resource.id if resource))
+      if !roles.include?(role)
+        self.class.define_dynamic_method role_name, resource
+        self.roles << role
+      end
+    end
   
-  def has_role?(role_name, resource = nil)
-    query, values = build_query(role_name, resource)
-    self.roles.where(*query, *values).size > 0
-  end
+    def has_role?(role_name, resource = nil)
+      query, values = build_query(role_name, resource)
+      self.roles.where(*query, *values).size > 0
+    end
 
-  def has_all_roles?(*args)
-    conditions = []
-    values = []
-    args.each do |arg|
-      if arg.is_a? Hash
-        return false if !self.has_role?(arg[:name], arg[:resource])
-      elsif arg.is_a? String
-        return false if !self.has_role?(arg)
-      else
-        raise ArgumentError, "Invalid argument type: only hash or string allowed"
+    def has_all_roles?(*args)
+      conditions = []
+      values = []
+      args.each do |arg|
+        if arg.is_a? Hash
+          return false if !self.has_role?(arg[:name], arg[:resource])
+        elsif arg.is_a? String
+          return false if !self.has_role?(arg)
+        else
+          raise ArgumentError, "Invalid argument type: only hash or string allowed"
+        end
       end
+      true
     end
-    true
-  end
 
-  def has_any_role?(*args)
-    conditions = []
-    values = []
-    args.each do |arg|
-      if arg.is_a? Hash
-        a, v = build_query(arg[:name], arg[:resource])
-      elsif arg.is_a? String
-        a, v = build_query(arg)
-      else
-        raise ArgumentError, "Invalid argument type: only hash or string allowed"
+    def has_any_role?(*args)
+      conditions = []
+      values = []
+      args.each do |arg|
+        if arg.is_a? Hash
+          a, v = build_query(arg[:name], arg[:resource])
+        elsif arg.is_a? String
+          a, v = build_query(arg)
+        else
+          raise ArgumentError, "Invalid argument type: only hash or string allowed"
+        end
+        conditions << a
+        values += v
       end
-      conditions << a
-      values += v
+      self.roles.where([ conditions.join(' OR '), *values ]).size > 0
     end
-    self.roles.where([ conditions.join(' OR '), *values ]).size > 0
-  end
   
-  def has_no_role(role_name, resource = nil)
-    role = Role.where( :name => role_name)
-    role = role.where( :resource_type => resource.class.name,
-                       :resource_id => resource.id) if resource
-    self.roles.delete(role) if role
-  end
+    def has_no_role(role_name, resource = nil)
+      role = Role.where( :name => role_name)
+      role = role.where( :resource_type => resource.class.name,
+                         :resource_id => resource.id) if resource
+      self.roles.delete(role) if role
+    end
   
-  def roles_name
-    self.roles.select(:name).map { |r| r.name }
+    def roles_name
+      self.roles.select(:name).map { |r| r.name }
+    end
+ 
+    private
+ 
+    def build_query(role, resource = nil)
+      query = "((name = ?) AND (resource_type IS NULL) AND (resource_id IS NULL))"
+      values = [ role ]
+      if resource
+        query.insert(0, "(")
+        query += " OR ((name = ?) AND (resource_type = ?) AND (resource_id = ?)))" 
+        values << role << resource.class.name << resource.id
+      end
+      [ [ query ], values]
+    end
+
   end
+
+  module Reloaded
+ 
+    def load_dynamic_methods
+      Role.all.each do |r|
+        define_dynamic_method(r.name, r.resource)
+      end
+    end
+
+
+    def define_dynamic_method(role_name, resource)
+      class_eval do 
+        define_method("is_#{role_name}?".to_sym) do
+        has_role?("#{role_.name}")
+        end if !method_defined? "is_#{role_name}?".to_sym
   
-  private
-  
-  def build_query(role, resource = nil)
-    query = "((name = ?) AND (resource_type IS NULL) AND (resource_id IS NULL))"
-    values = [ role ]
-    if resource
-      query.insert(0, "(")
-      query += " OR ((name = ?) AND (resource_type = ?) AND (resource_id = ?)))" 
-      values << role << resource.class.name << resource.id
+        define_method("is_#{role_name}_of?".to_sym) do |arg|
+          has_role?("#{role_name}", arg)
+        end if !method_defined?("is_#{role_name}_of?".to_sym) && resource
+      end
     end
-    [ [ query ], values]
+    
   end
 end

data/lib/rolify/version.rb

@@ -1,3 +1,3 @@
 module Rolify
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/rolify/role_spec.rb

@@ -4,6 +4,8 @@ describe Rolify do
   context "in a Instance level" do 
     before(:all) do
       @admin = User.first
+      @admin.has_role "admin"
+      @admin.has_role "moderator", Forum.first
     end
 
     it "should respond to has_role method" do 
@@ -30,6 +32,15 @@ describe Rolify do
       @admin.should respond_to(:has_no_role).with(1).arguments
       @admin.should respond_to(:has_no_role).with(2).arguments
     end
+
+    it "should respond to dynamic methods" do
+      @admin.should respond_to(:is_admin?).with(0).arguments
+      @admin.should respond_to(:is_moderator_of?).with(1).arguments
+    end
+
+    it "should not respond to any unknown methods" do
+      @admin.should_not respond_to(:is_god?)
+    end
   end
 
   context "with a global role" do 

data/spec/support/models.rb

@@ -1,6 +1,7 @@
 class User < ActiveRecord::Base
   has_and_belongs_to_many :roles, :join_table => :users_roles
-  include Rolify
+  include Rolify::Roles
+  extend Rolify::Reloaded
 end
 
 class Role < ActiveRecord::Base
@@ -9,4 +10,4 @@ class Role < ActiveRecord::Base
 end
 
 class Forum < ActiveRecord::Base
-end
+end

metadata

@@ -2,7 +2,7 @@
 name: rolify
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Florent Monbillard
@@ -51,6 +51,7 @@ files:
 - README.rdoc
 - Rakefile
 - lib/generators/rolify/role/role_generator.rb
+- lib/generators/rolify/role/templates/initializer.rb
 - lib/generators/rolify/role/templates/migration.rb
 - lib/generators/rolify/role/templates/role.rb
 - lib/rolify.rb