the_role 2.1.1 → 2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27c23d0e82c72b3aa2f3f2c846d62424f50bb349
-  data.tar.gz: e7f1057d85c4ec5b0a8d60a227d7504810eedde9
+  metadata.gz: 77b00593bcd32d2fee50327a0c3fab22fbadf482
+  data.tar.gz: 269eb319746ed8f82864259c20ba46439ea59390
 SHA512:
-  metadata.gz: fab50cb0f7259c5a0902f1b2647078e978171eacb42e33a4bde402cf6bb86a5f4fcd814a2d3e27a975bbf3af0ea70278b9b4ebafd76832e1856d359fe21b70f7
-  data.tar.gz: f69efe7d0fe26e0b7d6a5423932e8c9f316f416b3fc0b9c6651da6990e80025cb9af1ea1cecfc0461ab905f8666a6b301fcd6f0c7cd2b37d2d491218765a2717
+  metadata.gz: 88afca09c44fe32449d4d8ca1d7bdfa60d9ad13f2d02fdf43c3fbb29931ec99377c9e6e4bf0c632c739f40f0858ec58d55eb59bffde8cbcb1e114cba33a6f518
+  data.tar.gz: cf2b3f534ad0d7a949590a563d722e9048161a91560c3db73940b08cd5db4ba72691055fab7c86d1c596ed408fa99a22cf8a5c0389a53cb3a6905c0d796e2b0b

data/.gitignore

@@ -1,6 +1,30 @@
 *.gem
+*.rbc
+
 .bundle
-Gemfile.lock
-pkg/*
+.config
+.yardoc
+
 .rvmrc
-spec/the_role_on_devise/public/assets
+.ruby-gemset
+.ruby-version
+
+_yardoc
+coverage
+Gemfile.lock
+InstalledFiles
+lib/bundler/man
+spec/dummy_app/public/assets
+
+tmp
+doc
+pkg
+rdoc
+
+test/tmp
+spec/reports
+test/version_tmp
+
+.DS_Store
+.LSOverride
+.AppleDouble

data/.ruby-gemset.example

@@ -0,0 +1 @@
+the_role

data/.ruby-version.example

@@ -0,0 +1 @@
+ruby-2.0.0-p353

data/.rvmrc.example

@@ -1 +1 @@
-rvm use ruby-1.8.7-p357@the_role --create
+rvm use ruby-2.0.0-p353@the_role --create

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
 rvm:
   - 1.9.3
-gemfile: spec/the_role_on_devise/Gemfile
-script: "cd spec/the_role_on_devise && rake db:bootstrap RAILS_ENV=test && rspec --format documentation"
+gemfile: spec/dummy_app/Gemfile
+script: "cd spec/dummy_app && rake db:bootstrap RAILS_ENV=test && rspec --format documentation"

data/README.md

@@ -41,7 +41,9 @@ puts following yields into your layout:
 gem 'the_role', '~> 2.0.0'
 ```
 
-[Rails 3 version](http://rubygems.org/gems/the_role/versions/1.7.0) (not recommended for use)
+## If you have any questions
+
+Please before ask anything try to launch and play with **[Dummy App](spec/dummy_app)** in spec folder. Maybe example of integration will be better than any documentation. Thank you!
 
 ### Instalation
 
@@ -68,10 +70,8 @@ gem 'the_role', '~> 2.0.0'
 ## Install
 
 ```ruby
-# Optional for UI.
-# You can use any Bootstrap version (CSS, LESS, SCSS)
-# You can find required components below
-gem 'bootstrap-sass', '~> 2.3.1.0'
+# You can use any Bootstrap 3 version (CSS, LESS, SCSS)
+gem 'bootstrap-sass', github: 'thomas-mcdonald/bootstrap-sass'
 
 gem "the_role", "~> 2.0.0"
 ```
@@ -110,7 +110,9 @@ end
 
 ```ruby
 class User < ActiveRecord::Base
-  include TheRoleUserModel
+  include TheRole::User
+  # or following alias for AR:
+  # has_role
 
   # has_many :pages
 end
@@ -124,6 +126,16 @@ Generate Role model
 bundle exec rails g the_role install
 ```
 
+or you can create Role model manually:
+
+```ruby
+class Role < ActiveRecord::Base
+  include TheRole::Role
+  # or following alias for AR:
+  # acts_as_role
+end
+```
+
 install TheRole migrations
 
 ```ruby
@@ -158,22 +170,35 @@ User.first.update( role: Role.with_name(:admin) )
 
 ```ruby
 class ApplicationController < ActionController::Base
-  include TheRoleController
+  include TheRole::Controller
 
   protect_from_forgery
 
-  # your Access Denied processor
   def access_denied
-    return render(text: 'access_denied: requires a role')
+    flash[:error] = t('the_role.access_denied')
+    redirect_to(:back)
   end
+end
+```
+### Configuration
+
+create the_role config:
+
+```
+bundle exec rails g the_role setup
+```
 
-  # 1) LOGIN_REQUIRE => authenticate_user!    for Devise
-  # 2) LOGIN_REQUIRE => require_login         for Sorcery
-  # 3) LOGIN_REQUIRE => user_require_method   for other Authentication solution
+**config/initializers/the_role.rb**
 
-  # Define method aliases for the correct TheRole's controller work
-  alias_method :login_required,     :LOGIN_REQUIRE
-  alias_method :role_access_denied, :access_denied
+```ruby
+TheRole.configure do |config|
+  config.layout                = :application
+  config.default_user_role     = :user
+  config.access_denied_method  = :access_denied      # define it in ApplicationController
+  config.login_required_method = :authenticate_user! # devise auth method
+
+  # config.first_user_should_be_admin = false
+  # config.destroy_strategy           = :restrict_with_exception # can be nil
 end
 ```
 
@@ -209,43 +234,17 @@ end
 **application.css**
 
 ```
-//= require the_role/bootstrap_sass
-//= require the_role
+//= require bootstrap
 ```
 
-If you don't use **bootstrap-sass** gem you should add the following componetns from your bootstrap version instead **the_role/bootstrap_sass**:
-
-```
-bootstrap/variables
-bootstrap/mixins
-bootstrap/reset
-
-bootstrap/scaffolding
-bootstrap/grid
-bootstrap/layouts
-
-bootstrap/navs
-bootstrap/wells
-bootstrap/forms
-bootstrap/close
-bootstrap/tables
-bootstrap/navbar
-bootstrap/dropdowns
+**application.js**
 
-bootstrap/alerts
-bootstrap/buttons
-bootstrap/button-groups
 ```
+//= require jquery
+//= require jquery_ujs
 
-### Configuration
-
-config/initializers/the_role.rb
-
-```ruby
-TheRole.configure do |config|
-  config.layout            = :application # default Layout for TheRole UI
-  config.default_user_role = nil          # set default role (name)
-end
+//= require bootstrap
+//= require the_role_editinplace
 ```
 
 ## Understanding

data/app/assets/javascripts/the_role_editinplace.js.coffee

@@ -0,0 +1,32 @@
+showForm = (item) ->
+  holder = item.parents('.holder')
+  a_item = holder.children('span.a')
+  b_item = holder.children('span.b')
+
+  a_item.hide().off 'click'
+  b_item.css('visibility', 'visible')
+
+  holder.find('.btn-warning').click ->
+    item = $ @ 
+    hideForm item
+    item.parents('form')[0].reset()
+
+  holder.find('.btn-success').click ->
+    $(@).parents('form')[0].submit()
+  
+  b_item.find('input').keypress (event) ->
+    ENTER = 13
+    form  = $(event.target).parents('form')
+    form.submit() if event.which is ENTER
+
+hideForm = (item) ->
+  holder = item.parents('.holder')
+  a_item = holder.children('span.a')
+  b_item = holder.children('span.b')
+  
+  a_item.show()
+  b_item.css('visibility', 'hidden')
+  holder.find('.btn').off('click')
+  a_item.click -> showForm item
+
+$ -> $('span.a', 'h3, h5').click -> showForm $(@)

data/app/controllers/admin/role_sections_controller.rb

@@ -1,6 +1,6 @@
 class Admin::RoleSectionsController < ApplicationController
-  include TheRoleController
-  layout TheRole.config.layout.to_s
+  include TheRole::Controller
+  layout  TheRole.config.layout.to_s
 
   before_filter :login_required
   before_filter :role_required

data/app/controllers/admin/roles_controller.rb

@@ -1,6 +1,6 @@
 class Admin::RolesController < ApplicationController
-  include TheRoleController
-  layout TheRole.config.layout.to_s
+  include TheRole::Controller
+  layout  TheRole.config.layout.to_s
 
   before_filter :login_required
   before_filter :role_required

data/app/controllers/concerns/controller.rb

@@ -0,0 +1,23 @@
+module TheRole
+  module Controller
+    def login_required
+      send TheRole.config.login_required_method
+    end
+
+    def role_access_denied
+      send TheRole.config.access_denied_method
+    end
+
+    private
+
+    def role_required
+      role_access_denied unless current_user.has_role?(controller_path, action_name)
+    end
+
+    def owner_required
+      # TheRole: You should define OWNER CHECK OBJECT
+      # When editable object was found
+      role_access_denied unless current_user.owner?(@owner_check_object)
+    end
+  end
+end

data/{lib/generators/the_role/templates → app/models/_templates_}/role.rb

@@ -1,3 +1,3 @@
 class Role < ActiveRecord::Base
-  include RoleModel
+  acts_as_role
 end

data/app/models/concerns/base.rb

@@ -0,0 +1,37 @@
+module TheRole
+  module Base
+    def has_section? section_name
+      hash         =  role_hash
+      section_name =  TheRoleParam.process section_name
+      return true  if hash[section_name]
+      false
+    end
+
+    def has_role? section_name, rule_name
+      hash         =  role_hash
+      section_name =  TheRoleParam.process(section_name)
+      rule_name    =  TheRoleParam.process(rule_name)
+
+      return true  if hash.try(:[], 'system').try(:[], 'administrator')
+      return true  if hash.try(:[], 'moderator').try(:[], section_name)
+
+      return false unless hash[section_name]
+      return false unless hash[section_name].key? rule_name
+      hash[section_name][rule_name]
+    end
+
+    def any_role? roles_hash = {}
+      roles_hash.each_pair{|section, action| return true if has_role?(section, action)}
+      false
+    end
+
+    def moderator? section_name
+      section_name = TheRoleParam.process(section_name)
+      has_role? section_name, 'any_crazy_name'
+    end
+
+    def admin?
+      has_role? 'any_crazy_name', 'any_crazy_name'
+    end
+  end
+end

data/app/models/concerns/role.rb

@@ -0,0 +1,134 @@
+module TheRole
+  module Role
+    extend ActiveSupport::Concern
+
+    include TheRole::Base
+
+    def role_hash;
+      to_hash;
+    end
+
+    alias_method :has?, :has_role?
+    alias_method :any?, :any_role?
+
+    def has_section? section_name
+      to_hash.key? TheRoleParam.process(section_name)
+    end
+
+    included do
+      has_many  :users, dependent: TheRole.config.destroy_strategy
+      validates :name,  presence: true, uniqueness: true
+      validates :title, presence: true, uniqueness: true
+      validates :description, presence: true
+
+      before_save do
+        self.name = TheRoleParam.process(name)
+
+        rules_set = self.the_role
+        self.the_role = {}.to_json if rules_set.blank? # blank
+        self.the_role = rules_set.to_json if rules_set.is_a?(Hash) # Hash
+      end
+    end
+
+    module ClassMethods
+      def with_name name
+        ::Role.where(name: name).first
+      end
+    end
+
+    # C
+
+    def create_section section_name = nil
+      return false unless section_name
+      role = to_hash
+      section_name = TheRoleParam.process(section_name)
+      return false if section_name.blank?
+      return true if role[section_name]
+      role[section_name] = {}
+      update(the_role: role)
+    end
+
+    def create_rule section_name, rule_name
+      return false if     rule_name.blank?
+      return false unless create_section(section_name)
+      role = to_hash
+      rule_name = TheRoleParam.process(rule_name)
+      section_name = TheRoleParam.process(section_name)
+      return true if role[section_name][rule_name]
+      role[section_name][rule_name] = false
+      update(the_role: role)
+    end
+
+    # R
+
+    def to_hash
+      #return the hash if activerecord parsed the json from postgresql
+      return the_role if the_role.kind_of? Hash
+      begin
+        JSON.load(the_role) rescue {}
+      end
+    end
+
+    def to_json
+      the_role
+    end
+
+    # U
+
+    # source_hash will be reset to false
+    # except true items from new_role_hash
+    # all keys will become 'strings'
+    # look at lib/the_role/hash.rb to find definition of *underscorify_keys* method
+    def update_role new_role_hash
+      new_role_hash = new_role_hash.try(:to_hash) || {}
+      new_role = new_role_hash.underscorify_keys
+      role = to_hash.underscorify_keys.deep_reset(false)
+      role.deep_merge! new_role
+      update(the_role: role)
+    end
+
+    def rule_on section_name, rule_name
+      role = to_hash
+      rule_name = TheRoleParam.process(rule_name)
+      section_name = TheRoleParam.process(section_name)
+      return false unless role[section_name]
+      return false unless role[section_name].key? rule_name
+      return true if     role[section_name][rule_name]
+      role[section_name][rule_name] = true
+      update(the_role: role)
+    end
+
+    def rule_off section_name, rule_name
+      role = to_hash
+      rule_name = TheRoleParam.process(rule_name)
+      section_name = TheRoleParam.process(section_name)
+      return false unless role[section_name]
+      return false unless role[section_name].key? rule_name
+      return true unless role[section_name][rule_name]
+      role[section_name][rule_name] = false
+      update(the_role: role)
+    end
+
+    # D
+
+    def delete_section section_name = nil
+      return false unless section_name
+      role = to_hash
+      section_name = TheRoleParam.process(section_name)
+      return false if section_name.blank?
+      return false unless role[section_name]
+      role.delete section_name
+      update(the_role: role)
+    end
+
+    def delete_rule section_name, rule_name
+      role = to_hash
+      rule_name = TheRoleParam.process(rule_name)
+      section_name = TheRoleParam.process(section_name)
+      return false unless role[section_name]
+      return false unless role[section_name].key? rule_name
+      role[section_name].delete rule_name
+      update(the_role: role)
+    end
+  end
+end

data/app/models/concerns/user.rb

@@ -0,0 +1,57 @@
+module TheRole
+  module User
+    extend ActiveSupport::Concern
+
+    include TheRole::Base
+
+    included do
+      belongs_to :role
+      before_validation :set_default_role, on: :create
+      after_save { |user| user.instance_variable_set(:@role_hash, nil) }
+    end
+
+    module ClassMethods
+      def with_role name
+        ::Role.where(name: name).first.users
+      end
+    end
+
+    def role_hash;
+      @role_hash ||= role.try(:to_hash) || {}
+    end
+
+    # FALSE if object is nil
+    # If object is a USER - check for youself
+    # Check for owner field - :user_id
+    # Check for owner _object_ if owner field is not :user_id
+    def owner? obj
+      return false unless obj
+      return true if admin?
+
+      section_name = obj.class.to_s.tableize
+      return true if moderator?(section_name)
+
+      # obj is User, simple way to define user_id
+      return id == obj.id if obj.is_a?(self.class)
+
+      # few ways to define user_id
+      return id == obj.user_id if obj.respond_to? :user_id
+      return id == obj[:user_id] if obj[:user_id]
+      return id == obj[:user][:id] if obj[:user]
+      false
+    end
+
+    private
+
+    def set_default_role
+      unless role
+        default_role = ::Role.find_by_name(TheRole.config.default_user_role)
+        self.role = default_role if default_role
+      end
+
+      if self.class.count.zero? && TheRole.config.first_user_should_be_admin
+        self.role = TheRole.create_admin_role!
+      end
+    end
+  end
+end