third-prestige-rolify 3.3.0.rc5

data/lib/rolify/matchers.rb

@@ -0,0 +1,13 @@
+RSpec::Matchers.define :have_role do |*args|
+  match do |resource|
+    resource.has_role?(*args)
+  end
+
+  failure_message_for_should do |resource|
+    "expected to have role #{args.map(&:inspect).join(" ")}"
+  end
+
+  failure_message_for_should_not do |resource|
+    "expected not to have role #{args.map(&:inspect).join(" ")}"
+  end
+end

data/lib/rolify/railtie.rb

@@ -0,0 +1,20 @@
+require 'rolify'
+require 'rails'
+
+module Rolify
+  class Railtie < Rails::Railtie
+    initializer 'rolify.initialize' do
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Base.send :extend, Rolify
+      end
+      
+      config.before_initialize do
+        ::Mongoid::Document.module_eval do
+          def self.included(base)
+            base.extend Rolify
+          end
+        end
+      end if defined?(Mongoid)
+    end
+  end
+end

data/lib/rolify/resource.rb

@@ -0,0 +1,31 @@
+module Rolify
+  module Resource
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods 
+      def find_roles(role_name = nil, user = nil)
+        roles = user && (user != :any) ? user.roles : self.role_class
+        roles = roles.where(:resource_type => self.to_s)
+        roles = roles.where(:name => role_name.to_s) if role_name && (role_name != :any)
+        roles
+      end
+
+      def with_role(role_name, user = nil)
+        if role_name.is_a? Array
+          role_name.map!(&:to_s)
+        else
+          role_name = role_name.to_s
+        end
+        resources = self.adapter.resources_find(self.role_table_name, self, role_name)
+        user ? self.adapter.in(resources, user, role_name) : resources
+      end
+      alias :with_roles :with_role
+    end
+    
+    def applied_roles
+      self.roles + self.class.role_class.where(:resource_type => self.class.to_s, :resource_id => nil)
+    end
+  end
+end

data/lib/rolify/role.rb

@@ -0,0 +1,85 @@
+require "rolify/finders"
+
+module Rolify
+  module Role
+    extend Utils
+    
+    def self.included(base)
+      base.extend Finders
+    end
+          
+    def add_role(role_name, resource = nil)
+      role = self.class.adapter.find_or_create_by(role_name.to_s, 
+                                                  (resource.is_a?(Class) ? resource.to_s : resource.class.name if resource), 
+                                                  (resource.id if resource && !resource.is_a?(Class)))
+
+      if !roles.include?(role)
+        self.class.define_dynamic_method(role_name, resource) if Rolify.dynamic_shortcuts
+        self.class.adapter.add(self, role)
+      end
+      role
+    end
+    alias_method :grant, :add_role
+    deprecate :has_role, :add_role
+
+    def has_role?(role_name, resource = nil)
+      if new_record?
+        self.roles.detect { |r| r.name == role_name.to_s && (r.resource == resource || resource.nil?) }.present?
+      else
+        self.class.adapter.where(self.roles, :name => role_name, :resource => resource).size > 0
+      end
+    end
+
+    def has_all_roles?(*args)
+      args.each do |arg|
+        if arg.is_a? Hash
+          return false if !self.has_role?(arg[:name], arg[:resource])
+        elsif arg.is_a?(String) || arg.is_a?(Symbol)
+          return false if !self.has_role?(arg)
+        else
+          raise ArgumentError, "Invalid argument type: only hash or string or symbol allowed"
+        end
+      end
+      true
+    end
+
+    def has_any_role?(*args)
+      self.class.adapter.where(self.roles, *args).size > 0
+    end
+    
+    def only_has_role?(role_name, resource = nil)
+      return self.has_role?(role_name,resource) && self.roles.count == 1
+    end
+
+    def remove_role(role_name, resource = nil)
+      self.class.adapter.remove(self, role_name.to_s, resource)
+    end
+    
+    alias_method :revoke, :remove_role
+    deprecate :has_no_role, :remove_role
+
+    def roles_name
+      self.roles.select(:name).map { |r| r.name }
+    end
+
+    def method_missing(method, *args, &block)
+      if method.to_s.match(/^is_(\w+)_of[?]$/) || method.to_s.match(/^is_(\w+)[?]$/)
+        resource = args.first
+        self.class.define_dynamic_method $1, resource
+        return has_role?("#{$1}", resource)
+      end unless !Rolify.dynamic_shortcuts
+      super
+    end
+
+    def respond_to?(method, include_private = false)
+      if Rolify.dynamic_shortcuts && (method.to_s.match(/^is_(\w+)_of[?]$/) || method.to_s.match(/^is_(\w+)[?]$/))
+        query = self.class.role_class.where(:name => $1)
+        query = self.class.adapter.exists?(query, :resource_type) if method.to_s.match(/^is_(\w+)_of[?]$/)
+        return true if query.count > 0
+        false
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rolify/utils.rb

@@ -0,0 +1,10 @@
+module Rolify
+  module Utils
+    def deprecate(old_method, new_method)
+      define_method(old_method) do |*args|
+        warn "[DEPRECATION] #{caller.first}: `#{old_method}` is deprecated.  Please use `#{new_method}` instead."
+        send(new_method, *args)
+      end
+    end
+  end
+end

data/lib/rolify/version.rb

@@ -0,0 +1,3 @@
+module Rolify
+  VERSION = "3.3.0.rc5"
+end

data/rolify.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rolify/version"
+
+Gem::Specification.new do |s|
+  s.name        = "third-prestige-rolify"
+  s.version     = Rolify::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Florent Monbillard"]
+  s.email       = ["f.monbillard@gmail.com"]
+  s.homepage    = "http://github.com/thirdprestige/rolify/"
+  s.summary     = %q{Roles library with resource scoping}
+  s.description = %q{Very simple Roles library without any authorization enforcement supporting scope on resource objects (instance or class). Supports ActiveRecord and Mongoid ORMs.}
+
+  s.rubyforge_project = s.name
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "ammeter"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", ">= 2.0"
+  s.add_development_dependency "rspec-rails", ">= 2.0"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "fuubar"
+  s.add_development_dependency "activerecord", ">= 3.2.0"
+  s.add_development_dependency "mongoid", ">= 3.1"
+end

data/spec/README.rdoc

@@ -0,0 +1,24 @@
+= Rolify Specs
+
+== Running the specs
+
+To run the specs first run the +bundle+ command to install the necessary gems and the +rake+ command to run the specs.
+
+  bundle
+  rake
+
+== Model Adapters
+
+Rolify currently supports 2 different ORMs: ActiveRecord and Mongoid. By default it will use Active Record but you can change this by setting the +ADAPTER+ environment variable before running the specs. You can run the +bundle+ command with this as well to ensure you have all the required gems.
+
+  ADAPTER=mongoid bundle
+  ADAPTER=mongoid rake
+
+The different model adapters you can specify are:
+
+* active_record (default)
+* mongoid
+
+You can also run the +spec_all+ rake task to run specs for each adapter.
+
+  rake spec_all

data/spec/generators/rolify/rolify_activerecord_generator_spec.rb

@@ -0,0 +1,163 @@
+require 'generators_helper'
+
+require 'rails/all'
+# Generators are not automatically loaded by Rails
+require 'generators/rolify/rolify_generator'
+
+describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'active_record' do
+  # Tell the generator where to put its output (what it thinks of as Rails.root)
+  destination File.expand_path("../../../../tmp", __FILE__)
+  teardown :cleanup_destination_root
+  
+  before { 
+    prepare_destination
+  }
+  
+  def cleanup_destination_root
+    FileUtils.rm_rf destination_root
+  end
+
+  describe 'specifying only Role class name' do
+    before(:all) { arguments %w(Role) }
+
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/user.rb" do
+          <<-RUBY
+          class User < ActiveRecord::Base
+          end
+          RUBY
+        end
+      }
+      require File.join(destination_root, "app/models/user.rb")
+      run_generator 
+    }
+    
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      it { should exist }
+      it { should contain "Rolify.configure do |config|"}
+      it { should contain "# config.use_dynamic_shortcuts" }
+      it { should contain "# config.use_mongoid" }
+    end
+    
+    describe 'app/models/role.rb' do
+      subject { file('app/models/role.rb') }
+      it { should exist }
+      it { should contain "class Role < ActiveRecord::Base" }
+      it { should contain "has_and_belongs_to_many :users, :join_table => :users_roles" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+    end
+    
+    describe 'app/models/user.rb' do
+      subject { file('app/models/user.rb') }
+      it { should contain /class User < ActiveRecord::Base\n  rolify\n/ }
+    end
+    
+    describe 'migration file' do
+      subject { migration_file('db/migrate/rolify_create_roles.rb') }
+      
+      it { should be_a_migration }
+      it { should contain "create_table(:roles) do" }
+      it { should contain "create_table(:users_roles, :id => false) do" }
+    end
+  end
+
+  describe 'specifying User and Role class names' do
+    before(:all) { arguments %w(AdminRole AdminUser) }
+    
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/admin_user.rb" do
+          "class AdminUser < ActiveRecord::Base\nend"
+        end
+      }
+      require File.join(destination_root, "app/models/admin_user.rb")
+      run_generator
+    }
+    
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      
+      it { should exist }
+      it { should contain "Rolify.configure(\"AdminRole\") do |config|"}
+      it { should contain "# config.use_dynamic_shortcuts" }
+      it { should contain "# config.use_mongoid" }
+    end
+    
+    describe 'app/models/admin_role.rb' do
+      subject { file('app/models/admin_role.rb') }
+      
+      it { should exist }
+      it { should contain "class AdminRole < ActiveRecord::Base" }
+      it { should contain "has_and_belongs_to_many :admin_users, :join_table => :admin_users_admin_roles" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+    end
+    
+    describe 'app/models/admin_user.rb' do
+      subject { file('app/models/admin_user.rb') }
+      
+      it { should contain /class AdminUser < ActiveRecord::Base\n  rolify :role_cname => 'AdminRole'\n/ }
+    end
+    
+    describe 'migration file' do
+      subject { migration_file('db/migrate/rolify_create_admin_roles.rb') }
+      
+      it { should be_a_migration }
+      it { should contain "create_table(:admin_roles)" }
+      it { should contain "create_table(:admin_users_admin_roles, :id => false) do" }
+    end
+  end
+  
+  describe 'specifying namespaced User and Role class names' do
+    before(:all) { arguments %w(Admin::Role Admin::User) }
+    
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/admin/user.rb" do
+          <<-RUBY
+          module Admin
+            class User < ActiveRecord::Base
+              self.table_name_prefix = 'admin_'
+            end
+          end
+          RUBY
+        end
+      }
+      require File.join(destination_root, "app/models/admin/user.rb")
+      run_generator
+    }
+    
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      
+      it { should exist }
+      it { should contain "Rolify.configure(\"Admin::Role\") do |config|"}
+      it { should contain "# config.use_dynamic_shortcuts" }
+      it { should contain "# config.use_mongoid" }
+    end
+    
+    describe 'app/models/admin/role.rb' do
+      subject { file('app/models/admin/role.rb') }
+      
+      it { should exist }
+      it { should contain "class Admin::Role < ActiveRecord::Base" }
+      it { should contain "has_and_belongs_to_many :admin_users, :join_table => :admin_users_admin_roles" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+    end
+    
+    describe 'app/models/admin/user.rb' do
+      subject { file('app/models/admin/user.rb') }
+      
+      it { should contain /class User < ActiveRecord::Base\n  rolify :role_cname => 'Admin::Role'\n/ }
+    end
+    
+    describe 'migration file' do
+      subject { migration_file('db/migrate/rolify_create_admin_roles.rb') }
+      
+      it { should be_a_migration }
+      it { should contain "create_table(:admin_roles)" }
+      it { should contain "create_table(:admin_users_admin_roles, :id => false) do" }
+    end
+  end
+end

data/spec/generators/rolify/rolify_mongoid_generator_spec.rb

@@ -0,0 +1,112 @@
+require 'generators_helper'
+
+require 'mongoid'
+
+# Generators are not automatically loaded by Rails
+require 'generators/rolify/rolify_generator'
+
+describe Rolify::Generators::RolifyGenerator, :if => ENV['ADAPTER'] == 'mongoid' do
+  # Tell the generator where to put its output (what it thinks of as Rails.root)
+  destination File.expand_path("../../../../tmp", __FILE__)
+  teardown :cleanup_destination_root
+  
+  before { 
+    prepare_destination
+  }
+  
+  def cleanup_destination_root
+    FileUtils.rm_rf destination_root
+  end
+
+  describe 'specifying ORM adapter' do 
+    before(:all) { arguments [ "Role", "User", "--orm=mongoid" ] }
+    
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/user.rb" do
+<<-RUBY
+class User
+  include Mongoid::Document
+
+  field :login, :type => String
+end
+RUBY
+        end
+      }
+      require File.join(destination_root, "app/models/user.rb")
+      run_generator
+    }
+      
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      it { should exist }
+      it { should contain "Rolify.configure do |config|"}
+      it { should_not contain "# config.use_mongoid" }
+      it { should contain "# config.use_dynamic_shortcuts" }
+    end
+    
+    describe 'app/models/role.rb' do
+      subject { file('app/models/role.rb') }
+      it { should exist }
+      it { should contain "class Role\n" }
+      it { should contain "has_and_belongs_to_many :users\n" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+      it { should contain "field :name, :type => String" }
+      it { should contain "  index({\n"
+                          "      { :name => 1 },\n"
+                          "      { :resource_type => 1 },\n"
+                          "      { :resource_id => 1 }\n"
+                          "    },\n"
+                          "    { unique => true })"}
+    end
+    
+    describe 'app/models/user.rb' do
+      subject { file('app/models/user.rb') }
+      it { should contain /class User\n  include Mongoid::Document\n  rolify\n/ }
+    end
+  end
+  
+  describe 'specifying namespaced User and Role class names and ORM adapter' do
+    before(:all) { arguments %w(Admin::Role Admin::User --orm=mongoid) }
+    
+    before { 
+      capture(:stdout) {
+        generator.create_file "app/models/admin/user.rb" do
+<<-RUBY
+module Admin
+  class User
+    include Mongoid::Document
+  end
+end
+RUBY
+        end
+      }
+      require File.join(destination_root, "app/models/admin/user.rb")
+      run_generator
+    }
+    
+    describe 'config/initializers/rolify.rb' do
+      subject { file('config/initializers/rolify.rb') }
+      
+      it { should exist }
+      it { should contain "Rolify.configure(\"Admin::Role\") do |config|"}
+      it { should contain "# config.use_dynamic_shortcuts" }
+      it { should_not contain "# config.use_mongoid" }
+    end
+    
+    describe 'app/models/admin/role.rb' do
+      subject { file('app/models/admin/role.rb') }
+      
+      it { should exist }
+      it { should contain "class Admin::Role" }
+      it { should contain "has_and_belongs_to_many :admin_users" }
+      it { should contain "belongs_to :resource, :polymorphic => true" }
+    end
+    
+    describe 'app/models/admin/user.rb' do
+      subject { file('app/models/admin/user.rb') }
+      
+      it { should contain /class User\n    include Mongoid::Document\n  rolify :role_cname => 'Admin::Role'\n/ }
+    end
+  end
+end