act_as_permission_controllable 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b4379261968ca8f86b6ca67b33cf64c035320386
+  data.tar.gz: 40b729251abe3516f8d70d3e2873d6ff38785296
+SHA512:
+  metadata.gz: 02e1a461c3171a6701efbdd49a4eca78e8808b1da050c8f2d2ca2d823f28f13dd9d3da041f0381a0312fffd87e32ce0b1b7443afc7e12c592c033351d51ea846
+  data.tar.gz: 39dead1069325510c18ab99d1439ee91d5b52fdd3a05e9c0b5aa84a2a94c8483829f5a9ba7b0512674b4c2d559201769d7b74ec15f8d83688ad4249db04bc80c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Cai Guanhao (Choi Goon-ho)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,212 @@
+# ActAsPermissionControllable
+
+*Control user / admin permissions with cancancan.*
+
+Easily integrate cancancan into your application with permission control of every controller action.
+
+![aapc](https://user-images.githubusercontent.com/1284703/29483144-bd8abd5a-84d2-11e7-99de-3741b727621c.png)
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'act_as_permission_controllable'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install act_as_permission_controllable
+```
+
+## Migration
+Add a `permissions` JSONB field to your model:
+
+```bash
+rails g migration AddPermissionsToAdmins permissions:jsonb
+```
+
+Add `default: {}, nil: false`:
+
+```ruby
+class AddPermissionsToAdmins < ActiveRecord::Migration[5.1]
+  def change
+    add_column :admins, :permissions, :jsonb, default: {}, nil: false
+  end
+end
+```
+
+## Model
+Add `act_as_permission_controllable` to your model:
+
+```ruby
+class Admin < ApplicationRecord
+  act_as_permission_controllable # methods added: ban, permit, assign_permissions, can?
+end
+```
+
+Create `app/models/ability.rb`:
+```ruby
+class Ability
+  include ActAsPermissionControllable::Ability
+end
+```
+
+## Controller
+Add `grant_permission` to your base controller.
+Controllers inherited from it will need authorization.
+You can rescue from `CanCan::AccessDenied` error to show permission error message.
+You also need to define `current_ability` for `cancancan` to work.
+```ruby
+class Admin::BaseController < ApplicationController
+
+  # ... other code ...
+
+  grant_permission
+
+  rescue_from CanCan::AccessDenied do |exception|
+    respond_to do |format|
+      format.json {
+        render json: { message: exception.message }, status: 403
+      }
+      format.html {
+        render 'act_as_permission_controllable/forbidden', layout: 'admin', status: 403, locals: { exception: exception }
+      }
+    end
+  end
+
+  private
+
+    def current_ability
+      @current_ability ||= Ability.new(current_admin)
+    end
+
+  # ... other code ...
+end
+```
+
+If you don't want a controller to check user permission, use `skip_grant_permission`.
+```ruby
+class Admin::HomeController < Admin::BaseController
+  skip_grant_permission
+end
+```
+
+If your controller has different index page:
+```ruby
+class Admin::AdminsController < Admin::BaseController
+  grant_permission index: :welcome
+
+  def welcome
+  end
+end
+```
+
+To edit permissions on the web page, add actions to your routes:
+```ruby
+resources :admins do
+  member do
+    match :permissions, via: [ :get, :post ]
+  end
+end
+```
+
+And in your controller:
+```ruby
+class Admin::AdminsController < Admin::BaseController
+  # ... other code ...
+
+  def permissions
+    if request.post?
+      @admin.assign_permissions(params.fetch(:actions, []))
+      if @admin.save
+        flash[:notice] = 'OK!'
+      else
+        flash[:error] = 'ERROR!'
+      end
+      redirect_to params[:referer].presence || permissions_admin_admin_path(@admin)
+      return
+    end
+
+    render 'act_as_permission_controllable/permissions'
+  end
+
+  # ... other code ...
+end
+```
+
+## View
+You can use `controllable_nav_items` to list permitted pages for current user:
+```erb
+<ul class="nav navbar-nav">
+  <% controllable_nav_items do |item| %>
+    <%= content_tag :li, class: (name = item.controller_name) == controller.controller_name ? 'active' : nil do %>
+      <%= link_to item.i18n_name, (url_for(controller: name, action: item.index) rescue nil) %>
+    <% end %>
+  <% end %>
+</ul>
+```
+
+## I18n
+You can customize the names of each controller action and the order of each controller:
+```yaml
+# config/locales/aapc.en.yml
+en:
+  act_as_permission_controllable:
+    order:
+      - Admin::OrdersController
+      - Admin::SettingsController
+      - Admin::AdminsController
+    controllers:
+      Admin::AdminsController:   'Admins'
+      Admin::OrdersController:   'Orders'
+      Admin::SettingsController: 'Settings'
+    actions:
+      Admin::AdminsController:
+        permissions: 'View and Set Permissions'
+      Admin::OrdersController:
+        export: 'Export Orders'
+```
+
+## Methods
+### `ban(subject, *actions)` and `permit(subject, *actions)`
+```ruby
+# permit multiple actions of a controller
+Admin.find(1).permit(:user, :create, :update, :destroy).save
+
+# permit all actions in user controller
+Admin.find(1).permit(:user, :all).save
+
+# ban all except some permissions
+Admin.find(1).ban(:all).permit(:settings, :update).save
+
+# permit all except some permissions
+Admin.find(1).permit(:all).ban(:admin, :permissions).save
+
+# you can use controller class name as subject
+Admin.find(1).ban(:all).permit('Admin::SettingsController', :update).save
+```
+
+### `can?(action, subject)`
+```ruby
+if current_admin.can?(:destroy, :user)
+  # admin can destroy user
+end
+```
+
+## Example
+You can run the app in `test/dummy` directory and visit `http://admin.localhost.com:3000`.
+
+## Contributing
+
+You can open issues or pull requests on [GitHub](https://github.com/caiguanhao/act_as_permission_controllable).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActAsPermissionControllable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/views/act_as_permission_controllable/forbidden.html.erb

@@ -0,0 +1,13 @@
+<h1 class="text-danger"><sub class="glyphicon glyphicon-exclamation-sign"></sub> <%= t('act_as_permission_controllable.views.forbidden') %></h1>
+
+<h4><%= t('act_as_permission_controllable.views.forbidden_page') %></h4>
+
+<% if can?(:permissions, :admin) %>
+  <hr>
+  <div class="pull-right">
+    <small><code><%= "Admin.find(#{current_admin.id}).permit!(:#{exception.subject}, :#{exception.action})" %></code></small>
+  </div>
+  <div>
+    <%= link_to t('act_as_permission_controllable.views.edit_permissions'), permissions_admin_admin_path(current_admin), class: 'btn btn-default' %>
+  </div>
+<% end %>

data/app/views/act_as_permission_controllable/permissions.html.erb

@@ -0,0 +1,84 @@
+<% can_update = can? :permissions, :admin %>
+
+<%= form_tag permissions_admin_admin_path(@admin), method: :post do %>
+  <%= hidden_field_tag :referer, request.headers['Referer'] %>
+  <table class="table table-permissions" id="table-permissions">
+    <thead>
+      <tr>
+        <td colspan="5">
+          <%= submit_tag t('act_as_permission_controllable.views.update_permissions'),
+            class: 'btn btn-default pull-right', disabled: !can_update %>
+          <h4>
+            <%= t('act_as_permission_controllable.views.update_permissions') %>
+            <%= "(#{@admin.permission_count}/#{Admin.total_permission_count})" %>
+            <small>
+              <a class="toggle-checkboxes" href data-target="table-permissions">toggle</a>
+            </small>
+          </h4>
+        </td>
+      </tr>
+    </thead>
+    <tbody>
+      <% controllable_controllers.each_slice(5) do |slice| %>
+        <tr>
+          <% slice.each do |controller| %>
+            <td width="20%">
+              <strong>
+                <%= controller.i18n_name %>
+              </strong>
+              <small>
+                <a class="toggle-checkboxes" href data-target="checkboxes-<%= @cb = @cb.to_i + 1 %>">toggle</a>
+              </small>
+              <div class="checkboxes" id="checkboxes-<%= @cb %>">
+                <% controller.actions.each do |action| %>
+                  <div class="checkbox">
+                    <label>
+                      <%= check_box_tag "actions[#{action.controller.to_s}][]", action,
+                        action.permitted_in?(@admin.permissions), id: nil, disabled: !can_update %>
+                      <%= action.i18n_name %>
+                    </label>
+                  </div>
+                <% end %>
+              </div>
+            </td>
+          <% end %>
+        </tr>
+      <% end %>
+    </tbody>
+    <tfoot>
+      <tr>
+        <td class="active" colspan="5">
+          <%= submit_tag t('act_as_permission_controllable.views.update_permissions'),
+            class: 'btn btn-default', disabled: !can_update %>
+        </td>
+      </tr>
+    </tfoot>
+  </table>
+<% end %>
+
+<script>
+  (function () {
+    document.addEventListener('click', function (e) {
+      if (/\btoggle-checkboxes\b/.test(e.target.className)) {
+        e.preventDefault();
+        var target = e.target.dataset.target;
+        if (!target) return;
+        var targetElement = document.getElementById(target);
+        if (!targetElement) return;
+        var cbs = targetElement.querySelectorAll('input[type="checkbox"]');
+        var i;
+        var length = cbs.length;
+        var allChecked = true;
+        for (i = 0; i < length; i++) {
+          if (!cbs[i].checked) {
+            allChecked = false;
+            break;
+          }
+        }
+        for (i = 0; i < length; i++) {
+          cbs[i].checked = !allChecked;
+        }
+      }
+    }, false);
+  })();
+</script>

data/config/locales/en.yml

@@ -0,0 +1,15 @@
+en:
+  act_as_permission_controllable:
+    views:
+      forbidden: Forbidden
+      forbidden_page: Sorry, you're not allowed to visit the page you requested.
+      edit_permissions: Edit Permissions
+      update_permissions: Update Permissions
+    actions:
+      new:     'New %{model}'
+      create:  'Create New %{model}'
+      index:   '%{model} List'
+      show:    '%{model} Details'
+      edit:    'Edit %{model}'
+      update:  'Update %{model}'
+      destroy: 'Delete %{model}'

data/config/locales/zh_CN.yml

@@ -0,0 +1,15 @@
+zh_CN:
+  act_as_permission_controllable:
+    views:
+      forbidden: 禁止访问
+      forbidden_page: 抱歉，管理员不允许你访问特定页面。
+      edit_permissions: 修改权限设置
+      update_permissions: 更新权限设置
+    actions:
+      new:     '新建%{model}'
+      create:  '创建%{model}'
+      index:   '%{model}列表'
+      show:    '%{model}详细页'
+      edit:    '编辑%{model}'
+      update:  '更改%{model}'
+      destroy: '删除%{model}'

data/lib/act_as_permission_controllable.rb

@@ -0,0 +1,8 @@
+require 'act_as_permission_controllable/act'
+require 'act_as_permission_controllable/ability'
+require 'act_as_permission_controllable/action'
+require 'act_as_permission_controllable/controller'
+require 'act_as_permission_controllable/helper'
+require 'act_as_permission_controllable/i18n'
+require 'act_as_permission_controllable/railtie'
+require 'cancancan'

data/lib/act_as_permission_controllable/ability.rb

@@ -0,0 +1,18 @@
+module ActAsPermissionControllable
+  module Ability
+    extend ActiveSupport::Concern
+
+    included do
+      include CanCan::Ability
+
+      def initialize(user)
+        return if !user || !(Hash === user.permissions)
+        user.permissions.each do |controller_name, actions|
+          controller = controller_name.safe_constantize
+          next if controller.nil?
+          can actions.map(&:to_sym), controller.controller_name.singularize.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/act_as_permission_controllable/act.rb

@@ -0,0 +1,34 @@
+require 'act_as_permission_controllable/model'
+
+module ActAsPermissionControllable
+  module Act
+    module Model
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def act_as_permission_controllable
+          include ActAsPermissionControllable::Model
+        end
+      end
+    end
+
+    module Controller
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def grant_permission(options = {})
+          ActAsPermissionControllable::Controller.set(self, options.slice(:index))
+
+          def self.inherited(subclass)
+            ActAsPermissionControllable::Controller.set(subclass, {})
+            super
+          end
+        end
+
+        def skip_grant_permission
+          ActAsPermissionControllable::Controller.remove(self)
+        end
+      end
+    end
+  end
+end

data/lib/act_as_permission_controllable/action.rb

@@ -0,0 +1,35 @@
+module ActAsPermissionControllable
+  class Action
+    def self.actions_for_controller(controller)
+      controller.public_instance_methods(include_super = false).map { |action| self.new(action, controller) }
+    end
+
+    def initialize(action, controller)
+      @action = action
+      @controller = controller
+    end
+
+    def to_s
+      @action.to_s
+    end
+
+    def controller
+      @controller
+    end
+
+    def permitted_in?(permission_hash)
+      actions = permission_hash[controller.to_s]
+      (Array === actions) && actions.map(&:to_s).include?(to_s)
+    end
+
+    def i18n_name
+      model = Controller.new(controller).i18n_name
+      defaults = [
+        :"act_as_permission_controllable.actions.#{to_s}",
+        to_s.titleize,
+      ]
+      I18n.translate(:"act_as_permission_controllable.actions.#{controller.to_s}.#{to_s}",
+                     model: model, default: defaults)
+    end
+  end
+end

data/lib/act_as_permission_controllable/controller.rb

@@ -0,0 +1,90 @@
+module ActAsPermissionControllable
+  class Controller
+    mattr_accessor :permission_controllable_controllers do
+      Hash.new
+    end
+
+    mattr_accessor :preload_controller do
+      -> {
+        if ::Rails.application.config.cache_classes != true
+          ::Dir["#{::Rails.root}/app/controllers/**/*_controller.rb"].each do |file|
+            require file
+          end
+        end
+      }
+    end
+
+    def self.set(controller, options)
+      if !self.permission_controllable_controllers[controller.to_s]
+        controller.authorize_resource(class: false) # cancancan
+      end
+      self.permission_controllable_controllers[controller.to_s] = options
+    end
+
+    def self.remove(controller)
+      if self.permission_controllable_controllers[controller.to_s]
+        self.permission_controllable_controllers.delete(controller.to_s)
+        controller.skip_authorize_resource # cancancan
+      end
+    end
+
+    def self.get_controllers(sorted: false)
+      self.preload_controller.call if Proc === self.preload_controller
+
+      controllers = self.permission_controllable_controllers.map { |controller, _|
+        self.new(controller)
+      }.select(&:controllable?)
+
+      if sorted
+        order = I18n.t('act_as_permission_controllable.order', default: [[]])
+        controllers = controllers.sort_by(&:controller_name).sort_by.with_index { |controller, i|
+          [ order.index(controller.to_s) || order.size, i ]
+        }
+      end
+
+      controllers
+    end
+
+    def initialize(controller)
+      @controller = case controller
+                    when Symbol then controller.to_s.safe_constantize
+                    when String then controller.safe_constantize
+                    else controller
+                    end
+      @data = self.class.permission_controllable_controllers[@controller.to_s]
+    end
+
+    def nil?
+      @controller.nil?
+    end
+
+    def controllable?
+      !!@data && actions.present?
+    end
+
+    def controller_name
+      @controller.controller_name
+    end
+
+    def to_s
+      @controller.to_s
+    end
+
+    def i18n_name
+      name = controller_name.singularize
+      defaults = [
+        :"activerecord.models.#{name}",
+        name.camelize,
+      ]
+      I18n.translate(:"act_as_permission_controllable.controllers.#{to_s}", default: defaults)
+    end
+
+    def actions
+      Action.actions_for_controller(@controller)
+    end
+
+    def index
+      @data[:index].presence || :index
+    end
+  end
+end

data/lib/act_as_permission_controllable/helper.rb

@@ -0,0 +1,15 @@
+module ActAsPermissionControllable
+  module Helper
+    def controllable_nav_items(user = current_admin, &block)
+      @_controllable_nav_items ||= controllable_controllers.select do |controller|
+        actions = user.permissions[controller.to_s]
+        actions && actions.map(&:to_s).include?(controller.index.to_s)
+      end
+      block_given? ? @_controllable_nav_items.each(&block) : @_controllable_nav_items
+    end
+
+    def controllable_controllers
+      @_controllable_controllers ||= Controller.get_controllers(sorted: true)
+    end
+  end
+end

data/lib/act_as_permission_controllable/i18n.rb

@@ -0,0 +1 @@
+I18n.load_path += ::Dir[File.expand_path('../../../config/locales/*.yml', __FILE__)]

data/lib/act_as_permission_controllable/model.rb

@@ -0,0 +1,93 @@
+module ActAsPermissionControllable
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      def ban(subject, *actions)
+        control_permissions :ban, subject, *actions
+        self
+      end
+
+      def permit(subject, *actions)
+        control_permissions :permit, subject, *actions
+        self
+      end
+
+      def assign_permissions(attributes)
+        return if !attributes.respond_to?(:each)
+        perms, controllers = {}, Controller.get_controllers.map { |c| [ c.to_s, c ] }.to_h
+        attributes.each do |name, actions|
+          next if !(Array === actions)
+          next if (controller = controllers[name.to_s]).nil?
+          perms[name.to_s] = controller.actions.map(&:to_s) & actions.map(&:to_s)
+        end
+        self.permissions = perms
+      end
+
+      def self.total_permission_count
+        Controller.get_controllers.sum { |controller| controller.actions.size }
+      end
+
+      def permission_count
+        c = 0
+        Controller.get_controllers.each do |controller|
+          if actions = self.permissions[controller.to_s]
+            c += (controller.actions.map(&:to_s) & actions.map(&:to_s)).size
+          end
+        end
+        c
+      end
+
+      def can?(*args)
+        @current_ability ||= ::Ability.new(self)
+        @current_ability.can?(*args)
+      end
+
+      after_commit do
+        @current_ability = nil
+      end
+
+      private
+
+        def control_permissions(type, subject, *actions)
+          type = type.to_s
+
+          if subject == :all
+            Controller.get_controllers.each do |controller|
+              if type == 'permit'
+                self.permissions[controller.to_s] = controller.actions.map(&:to_s)
+              elsif type == 'ban'
+                self.permissions.delete(controller.to_s)
+              end
+            end
+            return
+          end
+
+          subject = subject.to_s
+          controller = Controller.get_controllers.find do |controller|
+            name, key = controller.controller_name, controller.to_s
+            subject == key || subject == name || subject == name.singularize
+          end
+
+          return if controller.nil?
+
+          key = controller.to_s
+          self.permissions[key] ||= []
+          if actions == [ :all ]
+            actions = controller.actions.map(&:to_s)
+          else
+            actions = actions.flatten.map(&:to_s)
+          end
+          if type == 'permit'
+            self.permissions[key] += actions
+          elsif type == 'ban'
+            self.permissions[key] -= actions
+          end
+          self.permissions[key].uniq!
+          self.permissions.delete(key) if self.permissions[key].empty?
+
+          return
+        end
+    end
+  end
+end

data/lib/act_as_permission_controllable/railtie.rb

@@ -0,0 +1,18 @@
+module ActAsImportable
+  class Railtie < ::Rails::Railtie
+    initializer "act_as_permission_controllable.active_record" do |app|
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.send :include, ActAsPermissionControllable::Act::Model
+      end
+
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.send :include, ActAsPermissionControllable::Act::Controller
+        ActionController::Base.append_view_path File.expand_path('../../../app/views', __FILE__)
+      end
+
+      ActiveSupport.on_load :action_view do
+        ActionView::Base.send :include, ActAsPermissionControllable::Helper
+      end
+    end
+  end
+end

data/lib/act_as_permission_controllable/version.rb

@@ -0,0 +1,3 @@
+module ActAsPermissionControllable
+  VERSION = '0.1.0'
+end

data/lib/tasks/act_as_permission_controllable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :act_as_permission_controllable do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: act_as_permission_controllable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cai Guanhao (Choi Goon-ho)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: cancancan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.21.0
+description: Easily integrate cancancan into your application with permission control
+  of every controller action.
+email:
+- caiguanhao@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/views/act_as_permission_controllable/forbidden.html.erb
+- app/views/act_as_permission_controllable/permissions.html.erb
+- config/locales/en.yml
+- config/locales/zh_CN.yml
+- lib/act_as_permission_controllable.rb
+- lib/act_as_permission_controllable/ability.rb
+- lib/act_as_permission_controllable/act.rb
+- lib/act_as_permission_controllable/action.rb
+- lib/act_as_permission_controllable/controller.rb
+- lib/act_as_permission_controllable/helper.rb
+- lib/act_as_permission_controllable/i18n.rb
+- lib/act_as_permission_controllable/model.rb
+- lib/act_as_permission_controllable/railtie.rb
+- lib/act_as_permission_controllable/version.rb
+- lib/tasks/act_as_permission_controllable_tasks.rake
+homepage: https://github.com/caiguanhao/act_as_permission_controllable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Control user / admin permissions with cancancan.
+test_files: []