rabarber 5.1.0 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 874cd3840269f288baec19fd5e240afdd6b06e3e5b81d703eb30e8e62283fb32
-  data.tar.gz: 117d060ffe53ae884b657c1d79a94d9762de1de8b6726659128d7be805c77e24
+  metadata.gz: 841b259e40b7e446647ee02fcca64cd183c64978c194edb6917ba344d9f12e92
+  data.tar.gz: 044c1aa8248f7b1b16f1c78648a0b4cafb0451f31d8fed5b72f6d3343a645c48
 SHA512:
-  metadata.gz: c2207e66e0743b7e5a81acfcc2707d00313fa2a8e9d8e652c7f0dc41b331d8cfa0c4d3504ff5e857606666f0145023a68e8c6d961d6285d48e36c435d4597a38
-  data.tar.gz: ea1ab97b91cb45611f4ca24a6418484a0b7634d00b0f96cec8485ba543500fc763a33f1e0cbaf7027a8a375623e91481ca1de74d47f50cf86fe5b91bfe456d0b
+  metadata.gz: a0880247a0c7f1af21dbb8099880d24ec200295e54f976855aac577fba55b692fee41a7ddfaf10f83848dfba20e2c0ac8289eb7bc94df21cabceb04da47925c1
+  data.tar.gz: 024e3093a753d53f158532c829ca245b159448d19901d884b4c09518e70b81d39d710ee0867339ca064bc0519fd06ef53a7af507149d29e80a2a2216ad92a096

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## v5.1.1
+
+### Misc:
+
+- Switched to `dry-types` for input validation
+- Switched to `dry-configurable` for configuration management
+
 ## v5.1.0
 
 ### Features:

data/README.md

@@ -18,8 +18,8 @@ Rabarber is a role-based authorization library for Ruby on Rails that focuses on
 **Gem Usage:**
   - [Installation](#installation)
   - [Configuration](#configuration)
-  - [Role Management](#role-management)
   - [User Role Methods](#user-role-methods)
+  - [Role Management](#role-management)
   - [Controller Authorization](#controller-authorization)
   - [Dynamic Rules](#dynamic-rules)
   - [Multi-tenancy / Context](#multi-tenancy--context)
@@ -27,7 +27,7 @@ Rabarber is a role-based authorization library for Ruby on Rails that focuses on
 
 
 **Community Resources:**
-  - [Contributing](#contributing)
+  - [Getting Help and Contributing](#getting-help-and-contributing)
   - [License](#license)
   - [Code of Conduct](#code-of-conduct)
   - [Old Versions](#old-versions)
@@ -80,30 +80,6 @@ To clear the role cache manually:
 Rabarber::Cache.clear
 ```
 
-## Role Management
-
-### Direct Role Operations
-
-```rb
-# Create a new role
-Rabarber::Role.add(:admin)
-
-# Rename a role
-Rabarber::Role.rename(:admin, :administrator)
-Rabarber::Role.rename(:admin, :administrator, force: true) # Force if role is assigned to users
-
-# Remove a role
-Rabarber::Role.remove(:admin)
-Rabarber::Role.remove(:admin, force: true) # Force if role is assigned to users
-
-# List available roles
-Rabarber::Role.names
-Rabarber::Role.all_names # All roles grouped by context
-
-# Get users assigned to a role
-Rabarber::Role.assignees(:admin)
-```
-
 ## User Role Methods
 
 Your user model is automatically augmented with role management methods:
@@ -137,6 +113,30 @@ user.roles
 user.all_roles
 ```
 
+## Role Management
+
+### Direct Role Operations
+
+```rb
+# Create a new role
+Rabarber::Role.add(:admin)
+
+# Rename a role
+Rabarber::Role.rename(:admin, :administrator)
+Rabarber::Role.rename(:admin, :administrator, force: true) # Force if role is assigned to users
+
+# Remove a role
+Rabarber::Role.remove(:admin)
+Rabarber::Role.remove(:admin, force: true) # Force if role is assigned to users
+
+# List available roles
+Rabarber::Role.names
+Rabarber::Role.all_names # All roles grouped by context
+
+# Get users assigned to a role
+Rabarber::Role.assignees(:admin)
+```
+
 ## Controller Authorization
 
 ### Basic Setup
@@ -182,9 +182,9 @@ class TicketsController < ApplicationController
     # Accessible to admin, manager, and support roles
   end
 
-  grant_access action: :destroy, roles: :admin
+  grant_access action: :destroy, roles: :owner, context: -> { Ticket.find(params[:id]) }
   def destroy
-    # Accessible to admin role only
+    # Accessible to admin and owner of the ticket
   end
 end
 ```
@@ -203,7 +203,9 @@ class InvoicesController < BaseController
 
   grant_access action: :index, roles: :manager
   grant_access action: :index, roles: :supervisor
-  # Index is accessible to admin, accountant, manager, and supervisor
+  def index
+    # Index is accessible to admin, accountant, manager, and supervisor
+  end
 end
 ```
 
@@ -218,7 +220,14 @@ end
 
 class MixedController < ApplicationController
   grant_access action: :index # Unrestricted index action
+  def index
+    # Accessible to all users
+  end
+
   grant_access action: :show, roles: :member # Restricted show action
+  def show
+    # Accessible to members only
+  end
 end
 ```
 
@@ -242,6 +251,8 @@ class ApplicationController < ActionController::Base
 end
 ```
 
+By default, Rabarber will redirect back (HTML format) or return 403 (other formats).
+
 ## Dynamic Rules
 
 Add conditional logic to authorization rules:
@@ -253,9 +264,15 @@ class OrdersController < ApplicationController
 
   # Proc-based conditions
   grant_access action: :show, roles: :client, if: -> { current_user.company_id == Order.find(params[:id]).company_id }
+  def show
+    # Accessible to company managers unless suspended, and to clients if the client's company matches the order's company
+  end
 
   # Dynamic-only rules (no roles required, can be used with custom policies)
   grant_access action: :index, if: -> { OrdersPolicy.new(current_user).can_access?(:index) }
+  def index
+    # Accessible to company managers unless suspended, and to users based on custom policy logic
+  end
 
   private
 
@@ -301,9 +318,15 @@ class ProjectsController < ApplicationController
 
   # Instance-based context (method)
   grant_access action: :show, roles: :member, context: :current_project
+  def show
+    # Accessible to Project admin and members of the current project
+  end
 
   # Instance-based context (proc)
   grant_access action: :update, roles: :owner, context: -> { Project.find(params[:id]) }
+  def update
+    # Accessible to Project admin and owner of the current project
+  end
 
   private
 
@@ -356,7 +379,7 @@ Use conditional rendering based on roles:
 <% end %>
 ```
 
-## Contributing
+## Getting Help and Contributing
 
 ### Getting Help
 Have a question or need assistance? Open a discussion in our [discussions section](https://github.com/brownboxdev/rabarber/discussions) for:

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

@@ -21,11 +21,34 @@ module Rabarber
       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

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

@@ -81,11 +81,19 @@ 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(contexts:)

data/lib/rabarber/models/role.rb

@@ -6,7 +6,7 @@ module Rabarber
 
     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"
 
@@ -63,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
@@ -76,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.1.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.1.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

data/lib/rabarber/input/role.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    class Role < Rabarber::Input::Base
-      REGEX = /\A[a-z0-9_]+\z/
-
-      def valid?
-        Rabarber::Input::Types::Symbol.new(value).valid? && value.to_s.match?(REGEX)
-      end
-
-      private
-
-      def processed_value
-        value.to_sym
-      end
-
-      def default_error_message
-        "Role name must be a Symbol or a String and may only contain lowercase letters, numbers, and underscores"
-      end
-    end
-  end
-end

data/lib/rabarber/input/roles.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    class Roles < Rabarber::Input::Base
-      def value
-        Array(super)
-      end
-
-      def valid?
-        value.all? { |role_name| Rabarber::Input::Role.new(role_name).valid? }
-      end
-
-      private
-
-      def processed_value
-        value.map(&:to_sym)
-      end
-
-      def default_error_message
-        "Role names must be Symbols or Strings and may only contain lowercase letters, numbers, and underscores"
-      end
-    end
-  end
-end

data/lib/rabarber/input/types/boolean.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    module Types
-      class Boolean < Rabarber::Input::Base
-        def valid?
-          [true, false].include?(value)
-        end
-
-        private
-
-        def processed_value
-          value
-        end
-
-        def default_error_message
-          "Value must be a Boolean"
-        end
-      end
-    end
-  end
-end

data/lib/rabarber/input/types/proc.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  module Input
-    module Types
-      class Proc < Rabarber::Input::Base
-        def valid?
-          value.is_a?(::Proc)
-        end
-
-        private
-
-        def processed_value
-          value
-        end
-
-        def default_error_message
-          "Value must be a Proc"
-        end
-      end
-    end
-  end
-end

data/lib/rabarber/input/types/symbol.rb

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