effective_roles 1.4.4 → 1.5.0

data/spec/dummy/config/routes.rb

@@ -1,58 +0,0 @@
-Dummy::Application.routes.draw do
-  # The priority is based upon order of creation:
-  # first created -> highest priority.
-
-  # Sample of regular route:
-  #   match 'products/:id' => 'catalog#view'
-  # Keep in mind you can assign values other than :controller and :action
-
-  # Sample of named route:
-  #   match 'products/:id/purchase' => 'catalog#purchase', :as => :purchase
-  # This route can be invoked with purchase_url(:id => product.id)
-
-  # Sample resource route (maps HTTP verbs to controller actions automatically):
-  #   resources :products
-
-  # Sample resource route with options:
-  #   resources :products do
-  #     member do
-  #       get 'short'
-  #       post 'toggle'
-  #     end
-  #
-  #     collection do
-  #       get 'sold'
-  #     end
-  #   end
-
-  # Sample resource route with sub-resources:
-  #   resources :products do
-  #     resources :comments, :sales
-  #     resource :seller
-  #   end
-
-  # Sample resource route with more complex sub-resources
-  #   resources :products do
-  #     resources :comments
-  #     resources :sales do
-  #       get 'recent', :on => :collection
-  #     end
-  #   end
-
-  # Sample resource route within a namespace:
-  #   namespace :admin do
-  #     # Directs /admin/products/* to Admin::ProductsController
-  #     # (app/controllers/admin/products_controller.rb)
-  #     resources :products
-  #   end
-
-  # You can have the root of your site routed with "root"
-  # just remember to delete public/index.html.
-  # root :to => 'welcome#index'
-
-  # See how all your routes lay out with "rake routes"
-
-  # This is a legacy wild controller route that's not recommended for RESTful applications.
-  # Note: This route will make all actions in every controller accessible via GET requests.
-  # match ':controller(/:action(/:id))(.:format)'
-end

data/spec/dummy/db/schema.rb

@@ -1,46 +0,0 @@
-# encoding: UTF-8
-# This file is auto-generated from the current state of the database. Instead
-# of editing this file, please use the migrations feature of Active Record to
-# incrementally modify your database, and then regenerate this schema definition.
-#
-# Note that this schema.rb definition is the authoritative source for your
-# database schema. If you need to create the application database on another
-# system, you should be using db:schema:load, not running all the migrations
-# from scratch. The latter is a flawed and unsustainable approach (the more migrations
-# you'll amass, the slower it'll run and the greater likelihood for issues).
-#
-# It's strongly recommended to check this file into your version control system.
-
-ActiveRecord::Schema.define(:version => 1) do
-
-  create_table "users", force: true do |t|
-    t.string   "encrypted_password"
-    t.string   "reset_password_token"
-    t.datetime "reset_password_sent_at"
-    t.datetime "remember_created_at"
-    t.datetime "confirmation_sent_at"
-    t.datetime "confirmed_at"
-    t.string   "confirmation_token"
-    t.string   "unconfirmed_email"
-    t.integer  "sign_in_count",          default: 0
-    t.datetime "current_sign_in_at"
-    t.datetime "last_sign_in_at"
-    t.string   "current_sign_in_ip"
-    t.string   "last_sign_in_ip"
-    t.string   "email"
-    t.string   "first_name"
-    t.string   "last_name"
-    t.integer  "roles_mask",             default: 0
-    t.boolean  "archived",               default: false
-    t.datetime "updated_at"
-    t.datetime "created_at"
-  end
-
-  create_table "posts", force: true do |t|
-    t.string   "title"
-    t.integer  "roles_mask",             default: 0
-    t.datetime "updated_at"
-    t.datetime "created_at"
-  end
-
-end

data/spec/effective_roles_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-describe EffectiveRoles do
-  let(:roles) { [:superadmin, :admin, :member] }
-
-  let(:post) { Post.new }
-  let(:user) { User.new.tap { |user| user.roles = [] } }
-
-  let(:member) { User.new.tap { |user| user.roles = [:member] } }
-  let(:admin) { User.new.tap { |user| user.roles = [:admin] } }
-  let(:superadmin) { User.new.tap { |user| user.roles = [:superadmin] } }
-
-  before(:each) do
-    EffectiveRoles.setup { |config| config.roles = roles }
-  end
-
-  describe '#roles_for_roles_mask' do
-    it 'computes the appropriate roles for the given mask' do
-      EffectiveRoles.roles_for(nil).should eq []
-      EffectiveRoles.roles_for(0).should eq []
-      EffectiveRoles.roles_for(1).should eq [:superadmin]
-      EffectiveRoles.roles_for(2).should eq [:admin]
-      EffectiveRoles.roles_for(3).should eq [:superadmin, :admin]
-      EffectiveRoles.roles_for(4).should eq [:member]
-      EffectiveRoles.roles_for(5).should eq [:superadmin, :member]
-      EffectiveRoles.roles_for(6).should eq [:admin, :member]
-      EffectiveRoles.roles_for(7).should eq [:superadmin, :admin, :member]
-      EffectiveRoles.roles_for(8).should eq []
-    end
-  end
-
-  describe '#assignable_roles' do
-    it 'uses the full Hash syntax to return the appropriate roles based on the passed User' do
-      EffectiveRoles.setup do |config|
-        config.assignable_roles = {
-          'User' => {
-            :superadmin => [:superadmin, :admin, :member], # Superadmins may assign all roles on a User#edit screen
-            :admin => [:admin, :member],                   # Admins may only assign :admin, :member on a User#edit screen
-            :member => []                                  # Members can assign no roles
-          },
-          'Post' => {
-            :superadmin => [:superadmin],                   # Superadmins may assign ony superadmin on a Post#edit screen
-            :admin => [:superadmin, :admin],
-            :member => [:admin, :member]
-          }
-        }
-      end
-
-      # On a User#edit screen
-      EffectiveRoles.assignable_roles_for(nil, user).should eq [:superadmin, :admin, :member]
-      EffectiveRoles.assignable_roles_for(superadmin, user).should eq [:superadmin, :admin, :member]
-      EffectiveRoles.assignable_roles_for(admin, user).should eq [:admin, :member]
-      EffectiveRoles.assignable_roles_for(member, user).should eq []
-      EffectiveRoles.assignable_roles_for(user, user).should eq []
-
-      # On a Post#edit screen
-      EffectiveRoles.assignable_roles_for(nil, post).should eq [:superadmin, :admin, :member]
-      EffectiveRoles.assignable_roles_for(superadmin, post).should eq [:superadmin]
-      EffectiveRoles.assignable_roles_for(admin, post).should eq [:superadmin, :admin]
-      EffectiveRoles.assignable_roles_for(member, post).should eq [:admin, :member]
-      EffectiveRoles.assignable_roles_for(user, post).should eq []
-
-      # On an unsupported object #edit screen
-      EffectiveRoles.assignable_roles_for(nil, nil).should eq [:superadmin, :admin, :member]
-      EffectiveRoles.assignable_roles_for(superadmin, nil).should eq []
-      EffectiveRoles.assignable_roles_for(admin, nil).should eq []
-      EffectiveRoles.assignable_roles_for(member, nil).should eq []
-      EffectiveRoles.assignable_roles_for(user, nil).should eq []
-    end
-
-    it 'uses the simple Hash syntax to return the appropriate roles based on the passed User' do
-      EffectiveRoles.setup do |config|
-        config.assignable_roles = {
-          :superadmin => [:superadmin, :admin, :member], # Superadmins may assign any resource any role
-          :admin => [:admin, :member],                   # Admins may only assign the :admin or :member role
-          :member => []                                  # Members may not assign any roles
-        }
-      end
-
-      EffectiveRoles.assignable_roles_for(nil).should eq [:superadmin, :admin, :member]
-
-      EffectiveRoles.assignable_roles_for(superadmin).should eq [:superadmin, :admin, :member]
-      EffectiveRoles.assignable_roles_for(admin).should eq [:admin, :member]
-      EffectiveRoles.assignable_roles_for(member).should eq []
-      EffectiveRoles.assignable_roles_for(user).should eq []
-    end
-
-    it 'uses the Array syntax to return the appropriate roles based on the passed User' do
-      EffectiveRoles.setup do |config|
-        config.assignable_roles = [:admin, :member]
-      end
-
-      EffectiveRoles.assignable_roles_for(nil).should eq [:admin, :member]
-      EffectiveRoles.assignable_roles_for(superadmin).should eq [:admin, :member]
-      EffectiveRoles.assignable_roles_for(admin).should eq [:admin, :member]
-      EffectiveRoles.assignable_roles_for(member).should eq [:admin, :member]
-      EffectiveRoles.assignable_roles_for(user).should eq [:admin, :member]
-    end
-
-    it 'uses the Nil syntax to return all roles regardless of User' do
-      EffectiveRoles.setup do |config|
-        config.assignable_roles = nil
-      end
-
-      EffectiveRoles.assignable_roles_for(nil).should eq roles
-      EffectiveRoles.assignable_roles_for(superadmin).should eq roles
-      EffectiveRoles.assignable_roles_for(admin).should eq roles
-      EffectiveRoles.assignable_roles_for(member).should eq roles
-      EffectiveRoles.assignable_roles_for(user).should eq roles
-    end
-
-  end
-
-  describe '#disabled_roles' do
-    it 'uses the full Hash syntax to return the appropriate roles based on the passed User' do
-      EffectiveRoles.setup do |config|
-        config.disabled_roles = {
-          'User' => [:member],
-          'Post' => [:superadmin],
-        }
-      end
-
-      # On a User#edit screen
-      EffectiveRoles.disabled_roles_for(user).should eq [:member]
-      EffectiveRoles.disabled_roles_for(post).should eq [:superadmin]
-      EffectiveRoles.disabled_roles_for(nil).should eq []
-    end
-
-    it 'uses the lazy Hash syntax to return the appropriate roles based on the passed User' do
-      EffectiveRoles.setup do |config|
-        config.disabled_roles = {
-          'User' => :member,
-          'Post' => :superadmin,
-        }
-      end
-
-      # On a User#edit screen
-      EffectiveRoles.disabled_roles_for(user).should eq [:member]
-      EffectiveRoles.disabled_roles_for(post).should eq [:superadmin]
-      EffectiveRoles.disabled_roles_for(nil).should eq []
-    end
-
-  end
-
-
-
-end

data/spec/models/acts_as_role_restricted_spec.rb

@@ -1,218 +0,0 @@
-describe 'Acts As Role Restricted' do
-  let(:roles) { [:superadmin, :admin, :member] }
-
-  let(:user) { User.new.tap { |user| user.roles = [] } }
-  let(:member) { User.new.tap { |user| user.roles = [:member] } }
-  let(:admin) { User.new.tap { |user| user.roles = [:admin] } }
-  let(:superadmin) { User.new.tap { |user| user.roles = [:superadmin] } }
-  let(:member_and_admin) { User.new.tap { |user| user.roles = [:member, :admin] } }
-
-  before(:each) do
-    EffectiveRoles.setup { |config| config.roles = roles }
-  end
-
-  describe '#is_any?(roles)' do
-    context 'when subject has one of the roles in question' do
-      let(:post) { Post.new.tap { |post| post.roles = [:member] } }
-
-      it 'is true' do
-        post.is_any?(:admin, :member).should be(true)
-      end
-    end
-
-    context 'when subject does not have any of the roles in question' do
-      let(:post) { Post.new.tap { |post| post.roles = [:member] } }
-
-      it 'is false' do
-        post.is_any?(:admin, :superadmin).should be(false)
-      end
-    end
-
-    context 'when subject does not have any roles' do
-      let(:post) { Post.new }
-
-      it 'is false' do
-        post.is_any?(:member, :admin, :superadmin).should be(false)
-      end
-    end
-  end
-
-  describe '#roles_permit?(obj)' do
-    describe 'when subject has no roles' do
-      let(:post) { Post.new }
-
-      it 'should be true when passed nil' do
-        post.roles_permit?(nil).should eq true
-      end
-
-      it 'should be true for any user' do
-        post.roles_permit?(user).should eq true
-        post.roles_permit?(member).should eq true
-        post.roles_permit?(admin).should eq true
-        post.roles_permit?(superadmin).should eq true
-      end
-    end
-
-    describe 'when subject has one role' do
-      let(:post) { Post.new.tap { |post| post.roles = [:member] } }
-
-      it 'should be false when passed nil' do
-        post.roles_permit?(nil).should eq false
-      end
-
-      it 'should be false when passed object doesnt share roles' do
-        post.roles_permit?(user).should eq false
-        post.roles_permit?(admin).should eq false
-        post.roles_permit?(superadmin).should eq false
-      end
-
-      it 'should be true for a user with all the same roles' do
-        post.roles_permit?(member).should eq true
-        post.roles_permit?(member_and_admin).should eq true
-      end
-    end
-
-    describe 'when subject has multiple roles' do
-      let(:post) { Post.new.tap { |post| post.roles = [:member, :admin] } }
-
-      it 'should be false when passed nil' do
-        post.roles_permit?(nil).should eq false
-      end
-
-      it 'should be false when passed object doesnt share all roles' do
-        post.roles_permit?(user).should eq false
-        post.roles_permit?(superadmin).should eq false
-      end
-
-      it 'should be true for a user with overlapping roles' do
-        post.roles_permit?(member).should eq true
-        post.roles_permit?(admin).should eq true
-        post.roles_permit?(member_and_admin).should eq true
-      end
-    end
-  end
-
-  describe '#roles_overlap?(obj)' do
-    describe 'when subject has no roles' do
-      let(:post) { Post.new }
-
-      it 'should be true when passed nil' do
-        post.roles_overlap?(nil).should eq true
-      end
-
-      it 'should be true when user has no roles either' do
-        post.roles_overlap?(user).should eq true
-      end
-
-      it 'should be false for any user with roles' do
-        post.roles_overlap?(member).should eq false
-        post.roles_overlap?(admin).should eq false
-        post.roles_overlap?(superadmin).should eq false
-      end
-    end
-
-    describe 'when subject has one role' do
-      let(:post) { Post.new.tap { |post| post.roles = [:member] } }
-
-      it 'should be false when passed nil' do
-        post.roles_overlap?(nil).should eq false
-      end
-
-      it 'should be false when passed object doesnt share roles' do
-        post.roles_overlap?(user).should eq false
-        post.roles_overlap?(admin).should eq false
-        post.roles_overlap?(superadmin).should eq false
-      end
-
-      it 'should be true for a user with all the same roles' do
-        post.roles_overlap?(member).should eq true
-        post.roles_overlap?(member_and_admin).should eq true
-      end
-    end
-
-    describe 'when subject has multiple roles' do
-      let(:post) { Post.new.tap { |post| post.roles = [:member, :admin] } }
-
-      it 'should be false when passed nil' do
-        post.roles_overlap?(nil).should eq false
-      end
-
-      it 'should be false when passed object doesnt share all roles' do
-        post.roles_overlap?(user).should eq false
-        post.roles_overlap?(superadmin).should eq false
-      end
-
-      it 'should be true for a user with overlapping roles' do
-        post.roles_overlap?(member).should eq true
-        post.roles_overlap?(admin).should eq true
-        post.roles_overlap?(member_and_admin).should eq true
-      end
-    end
-  end
-
-
-  describe '#roles_match?(obj)' do
-    describe 'when subject has no roles' do
-      let(:post) { Post.new }
-
-      it 'should be true when passed nil' do
-        post.roles_match?(nil).should eq true
-      end
-
-      it 'should be true when user has no roles either' do
-        post.roles_match?(user).should eq true
-      end
-
-      it 'should be false for any user with roles' do
-        post.roles_match?(member).should eq false
-        post.roles_match?(admin).should eq false
-        post.roles_match?(superadmin).should eq false
-      end
-    end
-
-    describe 'when subject has one role' do
-      let(:post) { Post.new.tap { |post| post.roles = [:member] } }
-
-      it 'should be false when passed nil' do
-        post.roles_match?(nil).should eq false
-      end
-
-      it 'should be false when passed object doesnt share roles' do
-        post.roles_match?(user).should eq false
-        post.roles_match?(admin).should eq false
-        post.roles_match?(superadmin).should eq false
-      end
-
-      it 'should be true for a user with all the same roles' do
-        post.roles_match?(member).should eq true
-      end
-
-      it 'should be false when the user has more roles' do
-        post.roles_match?(member_and_admin).should eq false
-      end
-    end
-
-    describe 'when subject has multiple roles' do
-      let(:post) { Post.new.tap { |post| post.roles = [:member, :admin] } }
-
-      it 'should be false when passed nil' do
-        post.roles_match?(nil).should eq false
-      end
-
-      it 'should be false when passed object doesnt share all roles' do
-        post.roles_match?(user).should eq false
-        post.roles_match?(superadmin).should eq false
-        post.roles_match?(member).should eq false
-        post.roles_match?(admin).should eq false
-      end
-
-      it 'should be true for a user with same roles' do
-        post.roles_match?(member_and_admin).should eq true
-      end
-    end
-  end
-
-
-
-
-end