rabarber 5.0.0 → 5.1.1

data/lib/rabarber/configuration.rb

@@ -1,36 +1,54 @@
 # frozen_string_literal: true
 
-require "singleton"
+require "dry-configurable"
 
 module Rabarber
-  class Configuration
-    include Singleton
+  module Configuration
+    extend Dry::Configurable
 
-    attr_reader :cache_enabled, :current_user_method
-    attr_accessor :user_model_name
+    module_function
 
-    def initialize
-      @cache_enabled = true
-      @current_user_method = :current_user
-      @user_model_name = "User"
-    end
-
-    def cache_enabled=(value)
-      @cache_enabled = Rabarber::Input::Types::Boolean.new(
-        value, Rabarber::ConfigurationError, "Configuration `cache_enabled` must be a Boolean"
-      ).process
-    end
-
-    def current_user_method=(method_name)
-      @current_user_method = Rabarber::Input::Types::Symbol.new(
-        method_name, Rabarber::ConfigurationError, "Configuration `current_user_method` must be a Symbol or a String"
-      ).process
-    end
+    setting :cache_enabled,
+            default: true,
+            reader: true,
+            constructor: -> (value) do
+              Rabarber::Inputs.process(
+                value,
+                as: :boolean,
+                error: Rabarber::ConfigurationError,
+                message: "Invalid configuration `cache_enabled`, expected a boolean, got #{value.inspect}"
+              )
+            end
+    setting :current_user_method,
+            default: :current_user,
+            reader: true,
+            constructor: -> (value) do
+              Rabarber::Inputs.process(
+                value,
+                as: :symbol,
+                error: Rabarber::ConfigurationError,
+                message: "Invalid configuration `current_user_method`, expected a symbol or a string, got #{value.inspect}"
+              )
+            end
+    setting :user_model_name,
+            default: "User",
+            reader: true,
+            constructor: -> (value) do
+              Rabarber::Inputs.process(
+                value,
+                as: :string,
+                error: Rabarber::ConfigurationError,
+                message: "Invalid configuration `user_model_name`, expected an ActiveRecord model name, got #{value.inspect}"
+              )
+            end
 
     def user_model
-      Rabarber::Input::ArModel.new(
-        @user_model_name, Rabarber::ConfigurationError, "Configuration `user_model_name` must be an ActiveRecord model name"
-      ).process
+      Rabarber::Inputs.process(
+        user_model_name,
+        as: :model,
+        error: Rabarber::ConfigurationError,
+        message: "Invalid configuration `user_model_name`, expected an ActiveRecord model name, got #{user_model_name.inspect}"
+      )
     end
   end
 end

data/lib/rabarber/controllers/concerns/authorization.rb

@@ -9,23 +9,46 @@ module Rabarber
       def with_authorization(options = {})
         before_action :with_authorization, **options
       rescue ArgumentError => e
-        raise Rabarber::Error, e.message
+        raise Rabarber::InvalidArgumentError, e.message
       end
 
       def skip_authorization(options = {})
         skip_before_action :with_authorization, **options
       rescue ArgumentError => e
-        raise Rabarber::Error, e.message
+        raise Rabarber::InvalidArgumentError, e.message
       end
 
       def grant_access(action: nil, roles: nil, context: nil, if: nil, unless: nil)
         Rabarber::Core::Permissions.add(
           self,
-          Rabarber::Input::Action.new(action).process,
-          Rabarber::Input::Roles.new(roles).process,
-          Rabarber::Input::AuthorizationContext.new(context).process,
-          Rabarber::Input::DynamicRule.new(binding.local_variable_get(:if)).process,
-          Rabarber::Input::DynamicRule.new(binding.local_variable_get(:unless)).process
+          Rabarber::Inputs.process(
+            action,
+            as: :symbol,
+            optional: true,
+            message: "Expected a symbol or a string, got #{action.inspect}"
+          ),
+          Rabarber::Inputs.process(
+            roles,
+            as: :roles,
+            message: "Expected an array of symbols or strings containing only lowercase letters, numbers, and underscores, got #{roles.inspect}"
+          ),
+          Rabarber::Inputs.process(
+            context,
+            as: :authorization_context,
+            message: "Expected a Class, an instance of ActiveRecord model, a symbol, a string, or a proc, got #{context.inspect}"
+          ),
+          Rabarber::Inputs.process(
+            binding.local_variable_get(:if),
+            as: :dynamic_rule,
+            optional: true,
+            message: "Expected a symbol, a string, or a proc, got #{binding.local_variable_get(:if).inspect}"
+          ),
+          Rabarber::Inputs.process(
+            binding.local_variable_get(:unless),
+            as: :dynamic_rule,
+            optional: true,
+            message: "Expected a symbol, a string, or a proc, got #{binding.local_variable_get(:unless).inspect}"
+          )
         )
       end
     end
@@ -39,7 +62,7 @@ module Rabarber
     end
 
     def when_unauthorized
-      request.format.html? ? redirect_back(fallback_location: root_path) : head(:unauthorized)
+      request.format.html? ? redirect_back(fallback_location: root_path) : head(:forbidden)
     end
   end
 end

data/lib/rabarber/core/cache.rb

@@ -20,7 +20,7 @@ module Rabarber
       end
 
       def enabled?
-        Rabarber::Configuration.instance.cache_enabled
+        Rabarber::Configuration.cache_enabled
       end
 
       def clear

data/lib/rabarber/core/roleable.rb

@@ -4,12 +4,12 @@ module Rabarber
   module Core
     module Roleable
       def roleable
-        current_roleable = send(Rabarber::Configuration.instance.current_user_method)
+        current_roleable = send(Rabarber::Configuration.current_user_method)
 
-        unless current_roleable.is_a?(Rabarber::Configuration.instance.user_model)
+        unless current_roleable.is_a?(Rabarber::Configuration.user_model)
           raise(
             Rabarber::Error,
-            "Expected `#{Rabarber::Configuration.instance.current_user_method}` to return an instance of #{Rabarber::Configuration.instance.user_model_name}, but got #{current_roleable.inspect}"
+            "Expected `#{Rabarber::Configuration.current_user_method}` to return an instance of #{Rabarber::Configuration.user_model_name}, got #{current_roleable.inspect}"
           )
         end
 

data/lib/rabarber/core/rule.rb

@@ -35,11 +35,12 @@ module Rabarber
       end
 
       def resolve_context(controller_instance)
-        case context
-        when Proc then Rabarber::Input::Context.new(controller_instance.instance_exec(&context)).process
-        when Symbol then Rabarber::Input::Context.new(controller_instance.send(context)).process
-        else context
-        end
+        resolved_context = case context
+                           when Proc then controller_instance.instance_exec(&context)
+                           when Symbol then controller_instance.send(context)
+                           else context
+                           end
+        Rabarber::Inputs.process(resolved_context, as: :role_context, message: "Expected an instance of ActiveRecord model, a Class, or nil, got #{resolved_context.inspect}")
       end
     end
   end

data/lib/rabarber/inputs.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "dry-types"
+
+module Rabarber
+  module Inputs
+    extend self
+
+    include Dry.Types()
+
+    PROC_TYPE = self::Instance(Proc)
+    SYMBOL_TYPE = self::Coercible::Symbol.constrained(min_size: 1)
+    ROLE_TYPE = self::SYMBOL_TYPE.constrained(format: /\A[a-z0-9_]+\z/)
+
+    CONTEXT_TYPE = self::Strict::Class | self::Instance(ActiveRecord::Base) | self::Hash.schema(
+      context_type: self::Strict::String | self::Nil,
+      context_id: self::Strict::String | self::Strict::Integer | self::Nil
+    ) | self::Nil
+
+    TYPES = {
+      boolean: self::Strict::Bool,
+      string: self::Strict::String.constrained(min_size: 1).constructor { _1.is_a?(::String) ? _1.strip : _1 },
+      symbol: self::SYMBOL_TYPE,
+      role: self::ROLE_TYPE,
+      roles: self::Array.of(self::ROLE_TYPE).constructor { Kernel::Array(_1) },
+      model: self::Strict::Class.constructor { _1.try(:safe_constantize) }.constrained(lt: ActiveRecord::Base),
+      dynamic_rule: self::SYMBOL_TYPE | self::PROC_TYPE,
+      role_context: self::CONTEXT_TYPE,
+      authorization_context: self::SYMBOL_TYPE | self::PROC_TYPE | self::CONTEXT_TYPE
+    }.freeze
+
+    def process(value, as:, optional: false, error: Rabarber::InvalidArgumentError, message: nil)
+      checker = type_for(as)
+      checker = checker.optional if optional
+
+      result = checker[value]
+
+      [:role_context, :authorization_context].include?(as) ? resolve_context(result) : result
+    rescue Dry::Types::CoercionError => e
+      raise error, message || e.message
+    end
+
+    private
+
+    def type_for(name) = self::TYPES.fetch(name)
+
+    def resolve_context(value)
+      case value
+      when nil
+        { context_type: nil, context_id: nil }
+      when Class
+        { context_type: value.to_s, context_id: nil }
+      when ActiveRecord::Base
+        raise Dry::Types::CoercionError, "instance context not persisted" unless value.persisted?
+
+        { context_type: value.class.to_s, context_id: value.public_send(value.class.primary_key) }
+      else
+        value
+      end
+    end
+  end
+end

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

@@ -40,7 +40,7 @@ module Rabarber
       )
 
       if roles_to_assign.any?
-        delete_roleable_cache(context: processed_context)
+        delete_roleable_cache(contexts: [processed_context])
         rabarber_roles << roles_to_assign
       end
 
@@ -56,13 +56,23 @@ module Rabarber
       )
 
       if roles_to_revoke.any?
-        delete_roleable_cache(context: processed_context)
+        delete_roleable_cache(contexts: [processed_context])
         self.rabarber_roles -= roles_to_revoke
       end
 
       roles(context: processed_context)
     end
 
+    def revoke_all_roles
+      return if rabarber_roles.none?
+
+      contexts = all_roles.keys.map { process_context(_1) }
+
+      rabarber_roles.clear
+
+      delete_roleable_cache(contexts:)
+    end
+
     private
 
     def create_new_roles(role_names, context:)
@@ -71,15 +81,23 @@ module Rabarber
     end
 
     def process_role_names(role_names)
-      Rabarber::Input::Roles.new(role_names).process
+      Rabarber::Inputs.process(
+        role_names,
+        as: :roles,
+        message: "Expected an array of symbols or strings containing only lowercase letters, numbers, and underscores, got #{role_names.inspect}"
+      )
     end
 
     def process_context(context)
-      Rabarber::Input::Context.new(context).process
+      Rabarber::Inputs.process(
+        context,
+        as: :role_context,
+        message: "Expected an instance of ActiveRecord model, a Class, or nil, got #{context.inspect}"
+      )
     end
 
-    def delete_roleable_cache(context:)
-      Rabarber::Core::Cache.delete([roleable_id, context], [roleable_id, :all])
+    def delete_roleable_cache(contexts:)
+      Rabarber::Core::Cache.delete(*contexts.map { [roleable_id, _1] }, [roleable_id, :all])
     end
 
     def roleable_id

data/lib/rabarber/models/role.rb

@@ -4,14 +4,9 @@ module Rabarber
   class Role < ActiveRecord::Base
     self.table_name = "rabarber_roles"
 
-    validates :name, presence: true,
-                     uniqueness: { scope: [:context_type, :context_id] },
-                     format: { with: Rabarber::Input::Role::REGEX },
-                     strict: true
-
     belongs_to :context, polymorphic: true, optional: true
 
-    has_and_belongs_to_many :roleables, class_name: Rabarber::Configuration.instance.user_model_name,
+    has_and_belongs_to_many :roleables, class_name: Rabarber::Configuration.user_model_name,
                                         association_foreign_key: "roleable_id",
                                         join_table: "rabarber_roles_roleables"
 
@@ -68,8 +63,7 @@ module Rabarber
       end
 
       def assignees(name, context: nil)
-        find_by(name: process_role_name(name), **process_context(context))&.roleables ||
-          Rabarber::Configuration.instance.user_model.none
+        find_by(name: process_role_name(name), **process_context(context))&.roleables || Rabarber::Configuration.user_model.none
       end
 
       private
@@ -81,11 +75,19 @@ module Rabarber
       end
 
       def process_role_name(name)
-        Rabarber::Input::Role.new(name).process
+        Rabarber::Inputs.process(
+          name,
+          as: :role,
+          message: "Expected a symbol or a string containing only lowercase letters, numbers, and underscores, got #{name.inspect}"
+        )
       end
 
       def process_context(context)
-        Rabarber::Input::Context.new(context).process
+        Rabarber::Inputs.process(
+          context,
+          as: :role_context,
+          message: "Expected an instance of ActiveRecord model, a Class, or nil, got #{context.inspect}"
+        )
       end
     end
 

data/lib/rabarber/railtie.rb

@@ -18,7 +18,7 @@ module Rabarber
             end
           end
         end
-        user_model = Rabarber::Configuration.instance.user_model
+        user_model = Rabarber::Configuration.user_model
         user_model.include Rabarber::HasRoles unless user_model < Rabarber::HasRoles
       end
     end

data/lib/rabarber/version.rb

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

data/lib/rabarber.rb

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 
 require_relative "rabarber/version"
-require_relative "rabarber/configuration"
 
 require "active_record"
 require "active_support"
 
-require_relative "rabarber/input/base"
-require_relative "rabarber/input/action"
-require_relative "rabarber/input/ar_model"
-require_relative "rabarber/input/authorization_context"
-require_relative "rabarber/input/context"
-require_relative "rabarber/input/dynamic_rule"
-require_relative "rabarber/input/role"
-require_relative "rabarber/input/roles"
-require_relative "rabarber/input/types/boolean"
-require_relative "rabarber/input/types/proc"
-require_relative "rabarber/input/types/symbol"
+require_relative "rabarber/inputs"
+
+require_relative "rabarber/configuration"
+
+module Rabarber
+  class Error < StandardError; end
+  class ConfigurationError < Rabarber::Error; end
+  class InvalidArgumentError < Rabarber::Error; end
+  class NotFoundError < Rabarber::Error; end
+
+  delegate :configure, to: Rabarber::Configuration
+  module_function :configure
+end
 
 require_relative "rabarber/core/cache"
 
@@ -32,15 +33,3 @@ require_relative "rabarber/core/permissions"
 require_relative "rabarber/core/integrity_checker"
 
 require_relative "rabarber/railtie"
-
-module Rabarber
-  class Error < StandardError; end
-  class ConfigurationError < Rabarber::Error; end
-  class InvalidArgumentError < Rabarber::Error; end
-  class NotFoundError < Rabarber::Error; end
-
-  def configure
-    yield(Rabarber::Configuration.instance)
-  end
-  module_function :configure
-end

data/rabarber.gemspec

@@ -21,5 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "dry-configurable", "~> 1.3"
+  spec.add_dependency "dry-types", "~> 1.8"
   spec.add_dependency "rails", ">= 7.1", "< 8.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rabarber
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.1.1
 platform: ruby
 authors:
 - enjaku4
@@ -10,6 +10,34 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -50,17 +78,7 @@ files:
 - lib/rabarber/core/rule.rb
 - lib/rabarber/helpers/helpers.rb
 - lib/rabarber/helpers/migration_helpers.rb
-- lib/rabarber/input/action.rb
-- lib/rabarber/input/ar_model.rb
-- lib/rabarber/input/authorization_context.rb
-- lib/rabarber/input/base.rb
-- lib/rabarber/input/context.rb
-- lib/rabarber/input/dynamic_rule.rb
-- lib/rabarber/input/role.rb
-- lib/rabarber/input/roles.rb
-- lib/rabarber/input/types/boolean.rb
-- lib/rabarber/input/types/proc.rb
-- lib/rabarber/input/types/symbol.rb
+- lib/rabarber/inputs.rb
 - lib/rabarber/models/concerns/has_roles.rb
 - lib/rabarber/models/role.rb
 - lib/rabarber/railtie.rb

data/lib/rabarber/input/action.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    class Action < Rabarber::Input::Base
-      def valid?
-        Rabarber::Input::Types::Symbol.new(value).valid? || value.nil?
-      end
-
-      private
-
-      def processed_value
-        value&.to_sym
-      end
-
-      def default_error_message
-        "Action name must be a Symbol or a String"
-      end
-    end
-  end
-end

data/lib/rabarber/input/ar_model.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    class ArModel < Rabarber::Input::Base
-      def valid?
-        processed_value < ActiveRecord::Base
-      rescue NameError
-        false
-      end
-
-      private
-
-      def processed_value
-        value.constantize
-      end
-
-      def default_error_message
-        "Value must be an ActiveRecord model"
-      end
-    end
-  end
-end

data/lib/rabarber/input/authorization_context.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    class AuthorizationContext < Rabarber::Input::Base
-      def valid?
-        Rabarber::Input::Context.new(value).valid? || Rabarber::Input::DynamicRule.new(value).valid?
-      end
-
-      private
-
-      def processed_value
-        case value
-        when String then value.to_sym
-        when Symbol, Proc then value
-        else Rabarber::Input::Context.new(value).process
-        end
-      end
-
-      def default_error_message
-        "Context must be a Class, an instance of ActiveRecord model, a Symbol, a String, or a Proc"
-      end
-    end
-  end
-end

data/lib/rabarber/input/base.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    class Base
-      attr_reader :value, :error_type, :error_message
-
-      def initialize(value, error_type = Rabarber::InvalidArgumentError, error_message = nil)
-        @value = value
-        @error_type = error_type
-        @error_message = error_message || default_error_message
-      end
-
-      def process
-        valid? ? processed_value : raise_error
-      end
-
-      def valid?
-        raise NotImplementedError
-      end
-
-      private
-
-      def processed_value
-        raise NotImplementedError
-      end
-
-      def default_error_message
-        raise NotImplementedError
-      end
-
-      def raise_error
-        raise error_type, error_message
-      end
-    end
-  end
-end

data/lib/rabarber/input/context.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    class Context < Rabarber::Input::Base
-      def valid?
-        value.nil? || value.is_a?(Class) || value.is_a?(ActiveRecord::Base) && value.persisted? || already_processed?
-      end
-
-      private
-
-      def processed_value
-        case value
-        when nil then { context_type: nil, context_id: nil }
-        when Class then { context_type: value.to_s, context_id: nil }
-        when ActiveRecord::Base then { context_type: value.class.to_s, context_id: value.public_send(value.class.primary_key) }
-        else value
-        end
-      end
-
-      def default_error_message
-        "Context must be a Class or an instance of ActiveRecord model"
-      end
-
-      def already_processed?
-        case value
-        in { context_type: NilClass | String, context_id: NilClass | String | Integer } then true
-        else false
-        end
-      end
-    end
-  end
-end

data/lib/rabarber/input/dynamic_rule.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    class DynamicRule < Rabarber::Input::Base
-      def valid?
-        Rabarber::Input::Types::Symbol.new(value).valid? || Rabarber::Input::Types::Proc.new(value).valid? || value.nil?
-      end
-
-      private
-
-      def processed_value
-        value.is_a?(String) ? value.to_sym : value
-      end
-
-      def default_error_message
-        "Dynamic rule must be a Symbol, a String, or a Proc"
-      end
-    end
-  end
-end