rabarber 1.2.2 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '084b409c4886e7622ee37f20b8f00c0d6e083546394bf3617bdd5277548a2764'
-  data.tar.gz: 62c3f5fb0496fc5a0cf95f04f0f04d26ba4f847bdf1e838c248361dca72744ee
+  metadata.gz: 77a15b7eb4164c74d70e81d34630d6051915acc2abe35896df8938d9cc53e473
+  data.tar.gz: 847f675e00e9a85a158032af7ddc158f3189df78d4e6dae4ce15e2fe5024515e
 SHA512:
-  metadata.gz: 0a1b141efb53f2b863f0dbbd1fe4c03ce199b7278bc0c51f8868866b918ea3161b8aebd9920872b43d9aea8cf24c5161b0f87d6d535a7c76295aa7890ee4b337
-  data.tar.gz: b740291aba6e4d1c529453e990c30e009b5215ccbdc99a5eac6c1b8c21d354c813e5bdd3f700c37e9aa22d528b025814ce69629aedb95449108a704e233c53d2
+  metadata.gz: 7d16835ed84fd9ee2c2e7871080c5256bad34944ee0c1a3448c609f14732f1c7901539c0287bc5206feddb79ef77ee4aa001dd26a642d7c23b05498f5a668659
+  data.tar.gz: 0bd35329a6608d4f6680b4aba7882d015df36f38e0b0d963c9df988edd40e490e67180e504b1901f05c957e27f8bffe585372f6494ccad2989310daaa7feec68

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.3.0
+
+- Add methods to directly add, rename, and remove roles
+- `HasRoles#assign_roles` and `HasRoles#revoke_roles` methods now return the list of roles assigned to the user
+- Minor performance improvements
+
 ## 1.2.2
 
 - Refactor to improve readability and maintainability

data/README.md

@@ -67,16 +67,16 @@ Rabarber can be configured by using `.configure` method in an initializer:
 
 ```rb
 Rabarber.configure do |config|
-  config.cache_enabled = false
-  config.current_user_method = :authenticated_user
-  config.must_have_roles = true
+  config.cache_enabled = true
+  config.current_user_method = :current_user
+  config.must_have_roles = false
   config.when_actions_missing = -> (missing_actions, context) { ... }
   config.when_roles_missing = -> (missing_roles, context) { ... }
   config.when_unauthorized = -> (controller) { ... }
 end
 ```
 
-- `cache_enabled` must be a boolean determining whether roles are cached. Roles are cached by default to avoid unnecessary database queries. If you want to disable caching, set this option to `false`. If caching is enabled and you need to clear the cache, use the `Rabarber::Cache.clear` method.
+- `cache_enabled` must be a boolean determining whether roles are cached. Roles are cached by default to avoid unnecessary database queries. If you want to disable caching, set this option to `false`. If caching is enabled and you need to clear the cache, use `Rabarber::Cache.clear` method.
 
 - `current_user_method` must be a symbol representing the method that returns the currently authenticated user. The default value is `:current_user`.
 
@@ -112,6 +112,7 @@ By default, `#assign_roles` method will automatically create any roles that don'
 ```rb
 user.assign_roles(:accountant, :marketer, create_new: false)
 ```
+The method returns an array of roles assigned to the user.
 
 **`#revoke_roles`**
 
@@ -122,6 +123,8 @@ user.revoke_roles(:accountant, :marketer)
 ```
 If any of the specified roles doesn't exist or the user doesn't have the role you want to revoke, it will be ignored.
 
+The method returns an array of roles assigned to the user.
+
 **`#has_role?`**
 
 To check whether the user has a role, use:
@@ -140,6 +143,51 @@ To view all the roles assigned to the user, use:
 user.roles
 ```
 
+---
+
+To manipulate roles directly, you can use `Rabarber::Role` methods:
+
+**`.add`**
+
+To add a new role, use:
+
+```rb
+Rabarber::Role.add(:admin)
+```
+
+This will create a new role with the specified name and return `true`. If the role already exists, it will return `false`.
+
+**`.rename`**
+
+To rename a role, use:
+
+```rb
+Rabarber::Role.rename(:admin, :administrator)
+```
+The first argument is the old name, and the second argument is the new name. This will rename the role and return `true`. If a role with the new name already exists, it will return `false`.
+
+The method won't rename the role if it is assigned to any user. To force the rename, use the method with `force: true` argument:
+```rb
+Rabarber::Role.rename(:admin, :administrator, force: true)
+```
+
+**`.remove`**
+
+To remove a role, use:
+
+```rb
+Rabarber::Role.remove(:admin)
+```
+
+This will remove the role and return `true`. If the role doesn't exist, it will return `false`.
+
+The method won't remove the role if it is assigned to any user. To force the removal, use the method with `force: true` argument:
+```rb
+Rabarber::Role.remove(:admin, force: true)
+```
+
+**`.names`**
+
 If you need to list all the role names available in your application, use:
 
 ```rb

data/lib/rabarber/cache.rb

@@ -10,16 +10,16 @@ module Rabarber
       enabled? ? Rails.cache.fetch(key, options, &block) : yield
     end
 
-    def delete(key)
-      Rails.cache.delete(key) if enabled?
+    def delete(*keys)
+      Rails.cache.delete_multi(keys) if enabled?
     end
 
     def enabled?
       Rabarber::Configuration.instance.cache_enabled
     end
 
-    def key_for(record)
-      "rabarber:roles_#{record.public_send(record.class.primary_key)}"
+    def key_for(id)
+      "rabarber:roles_#{id}"
     end
 
     def clear

data/lib/rabarber/models/concerns/has_roles.rb

@@ -17,7 +17,7 @@ module Rabarber
     end
 
     def roles
-      Rabarber::Cache.fetch(Rabarber::Cache.key_for(self), expires_in: 1.hour, race_condition_ttl: 5.seconds) do
+      Rabarber::Cache.fetch(Rabarber::Cache.key_for(roleable_id), expires_in: 1.hour, race_condition_ttl: 5.seconds) do
         rabarber_roles.names
       end
     end
@@ -31,15 +31,25 @@ module Rabarber
 
       create_new_roles(roles_to_assign) if create_new
 
-      rabarber_roles << Rabarber::Role.where(name: roles_to_assign) - rabarber_roles
+      new_roles = Rabarber::Role.where(name: roles_to_assign) - rabarber_roles
 
-      delete_cache
+      if new_roles.any?
+        delete_roleable_cache
+        rabarber_roles << new_roles
+      end
+
+      roles
     end
 
     def revoke_roles(*role_names)
-      self.rabarber_roles = rabarber_roles - Rabarber::Role.where(name: process_role_names(role_names))
+      new_roles = rabarber_roles - Rabarber::Role.where(name: process_role_names(role_names))
+
+      if rabarber_roles != new_roles
+        delete_roleable_cache
+        self.rabarber_roles = new_roles
+      end
 
-      delete_cache
+      roles
     end
 
     private
@@ -53,8 +63,12 @@ module Rabarber
       Rabarber::Input::Roles.new(role_names).process
     end
 
-    def delete_cache
-      Rabarber::Cache.delete(Rabarber::Cache.key_for(self))
+    def delete_roleable_cache
+      Rabarber::Cache.delete(Rabarber::Cache.key_for(roleable_id))
+    end
+
+    def roleable_id
+      public_send(self.class.primary_key)
     end
   end
 end

data/lib/rabarber/models/role.rb

@@ -6,16 +6,66 @@ module Rabarber
 
     validates :name, presence: true, uniqueness: true, format: { with: Rabarber::Input::Roles::REGEX }
 
-    after_commit :delete_cache
+    has_and_belongs_to_many :roleables, join_table: "rabarber_roles_roleables"
 
-    def self.names
-      pluck(:name).map(&:to_sym)
-    end
+    class << self
+      def names
+        pluck(:name).map(&:to_sym)
+      end
+
+      def add(name)
+        name = process_role_name(name)
+
+        return false if exists?(name: name)
+
+        delete_roles_cache
+
+        !!create!(name: name)
+      end
+
+      def rename(old_name, new_name, force: false)
+        role = find_by(name: process_role_name(old_name))
+        name = process_role_name(new_name)
+
+        return false if !role || exists?(name: name) || assigned_to_roleables(role).any? && !force
+
+        delete_roles_cache
+        delete_roleables_cache(role)
+
+        role.update!(name: name)
+      end
+
+      def remove(name, force: false)
+        role = find_by(name: process_role_name(name))
+
+        return false if !role || assigned_to_roleables(role).any? && !force
+
+        delete_roles_cache
+        delete_roleables_cache(role)
+
+        !!role.destroy!
+      end
+
+      private
+
+      def delete_roles_cache
+        Rabarber::Cache.delete(Rabarber::Cache::ALL_ROLES_KEY)
+      end
+
+      def delete_roleables_cache(role)
+        keys = assigned_to_roleables(role).map { |roleable_id| Rabarber::Cache.key_for(roleable_id) }
+        Rabarber::Cache.delete(*keys) if keys.any?
+      end
 
-    private
+      def assigned_to_roleables(role)
+        ActiveRecord::Base.connection.select_values(
+          "SELECT roleable_id FROM rabarber_roles_roleables WHERE role_id = #{role.id}"
+        )
+      end
 
-    def delete_cache
-      Rabarber::Cache.delete(Rabarber::Cache::ALL_ROLES_KEY)
+      def process_role_name(name)
+        Rabarber::Input::Roles.new(name).process[0]
+      end
     end
   end
 end

data/lib/rabarber/permissions.rb

@@ -15,22 +15,24 @@ module Rabarber
       @storage = { controller_rules: Hash.new({}), action_rules: Hash.new([]) }
     end
 
-    def self.add(controller, action, roles, dynamic_rule, negated_dynamic_rule)
-      rule = Rabarber::Rule.new(action, roles, dynamic_rule, negated_dynamic_rule)
-
-      if action
-        instance.storage[:action_rules][controller] += [rule]
-      else
-        instance.storage[:controller_rules][controller] = rule
+    class << self
+      def add(controller, action, roles, dynamic_rule, negated_dynamic_rule)
+        rule = Rabarber::Rule.new(action, roles, dynamic_rule, negated_dynamic_rule)
+
+        if action
+          instance.storage[:action_rules][controller] += [rule]
+        else
+          instance.storage[:controller_rules][controller] = rule
+        end
       end
-    end
 
-    def self.controller_rules
-      instance.storage[:controller_rules]
-    end
+      def controller_rules
+        instance.storage[:controller_rules]
+      end
 
-    def self.action_rules
-      instance.storage[:action_rules]
+      def action_rules
+        instance.storage[:action_rules]
+      end
     end
   end
 end

data/lib/rabarber/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rabarber
-  VERSION = "1.2.2"
+  VERSION = "1.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rabarber
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 1.3.0
 platform: ruby
 authors:
 - enjaku4
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-10 00:00:00.000000000 Z
+date: 2024-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -80,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: Simple authorization library for Ruby on Rails.