rabarber 6.0.2 → 6.1.0

data/lib/rabarber/engine.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module Rabarber
+  class Engine < Rails::Engine
+    initializer "rabarber.include_roleable" do
+      Rails.autoloaders.each do |autoloader|
+        autoloader.on_load do |cpath, klass, _abspath|
+          klass.include Rabarber::Roleable if cpath == Rabarber::Configuration.user_model_name
+        end
+      end
+    end
+
+    initializer "rabarber.to_prepare" do |app|
+      app.config.to_prepare do
+        Rabarber::Core::Permissions.reset! unless app.config.eager_load
+      end
+    end
+
+    initializer "rabarber.deprecator" do |app|
+      app.deprecators[:rabarber] = Rabarber.deprecator
+    end
+
+    initializer "rabarber.extend_migration_helpers" do
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Migration.include Rabarber::MigrationHelpers
+      end
+    end
+  end
+end

data/lib/rabarber/helpers/migration_helpers.rb

@@ -3,27 +3,16 @@
 module Rabarber
   module MigrationHelpers
     def migrate_authorization_context!(old_context, new_context)
-      roles = Rabarber::Role.where(context_type: old_context.to_s)
+      old_context_type = Rabarber::Inputs::NonEmptyString.new(old_context).process
+      new_context_type = Rabarber::Inputs::NonEmptyString.new(new_context).process
 
-      raise Rabarber::InvalidArgumentError, "No roles exist in context #{old_context.inspect}" unless roles.exists?
-      raise Rabarber::InvalidArgumentError, "Cannot migrate context to #{new_context.inspect}: class does not exist" unless new_context.to_s.safe_constantize
-
-      roles.update_all(context_type: new_context.to_s)
+      Rabarber::Role.where(context_type: old_context_type).update_all(context_type: new_context_type)
     end
 
     def delete_authorization_context!(context)
-      roles = Rabarber::Role.where(context_type: context.to_s)
-
-      raise Rabarber::InvalidArgumentError, "No roles exist in context #{context.inspect}" unless roles.exists?
+      context_type = Rabarber::Inputs::NonEmptyString.new(context).process
 
-      ActiveRecord::Base.transaction do
-        ActiveRecord::Base.connection.execute(
-          ActiveRecord::Base.sanitize_sql(
-            ["DELETE FROM rabarber_roles_roleables WHERE role_id IN (?)", roles.pluck(:id)]
-          )
-        )
-        roles.delete_all
-      end
+      Rabarber::Role.delete_with_assignments(Rabarber::Role.where(context_type:))
     end
   end
 end

data/lib/rabarber/inputs/base.rb

@@ -3,7 +3,7 @@
 module Rabarber
   module Inputs
     class Base
-      def initialize(value, optional: false, error: Rabarber::InvalidArgumentError, message: nil)
+      def initialize(value, optional: false, error: nil, message: nil)
         @value = value
         @optional = optional
         @error = error
@@ -22,8 +22,11 @@ module Rabarber
         raise NotImplementedError
       end
 
+      def default_error = Rabarber::InvalidArgumentError
+      def default_message = nil
+
       def raise_error
-        raise @error, @message
+        raise @error || default_error, @message || default_message
       end
     end
   end

data/lib/rabarber/inputs/boolean.rb

@@ -5,7 +5,9 @@ module Rabarber
     class Boolean < Rabarber::Inputs::Base
       private
 
-      def validate_and_normalize = @value == true || @value == false ? @value : raise_error
+      def default_message = "Expected a boolean, got `#{@value.inspect}`"
+
+      def validate_and_normalize = @value.equal?(true) || @value.equal?(false) ? @value : raise_error
     end
   end
 end

data/lib/rabarber/inputs/context.rb

@@ -10,20 +10,19 @@ module Rabarber
         when Class
           { context_type: context.to_s, context_id: nil }
         when ActiveRecord::Base
-          raise_error unless context.persisted?
-          { context_type: context.class.to_s, context_id: context.public_send(context.class.primary_key) }
-        else
-          context
+          { context_type: context.class.to_s, context_id: context.id }
         end
       end
 
       private
 
+      def default_error = Rabarber::InvalidContextError
+      def default_message = "Expected an instance of ActiveRecord model, a Class, or nil, got `#{@value.inspect}`"
+
       def validate_and_normalize
         return @value if @value.nil?
         return @value if @value.is_a?(Class)
-        return @value if @value.is_a?(ActiveRecord::Base)
-        return @value if @value in { context_type: String | nil, context_id: String | Integer | nil }
+        return @value if @value.is_a?(ActiveRecord::Base) && @value.persisted?
 
         raise_error
       end

data/lib/rabarber/inputs/contexts/authorizational.rb

@@ -4,15 +4,10 @@ module Rabarber
   module Inputs
     module Contexts
       class Authorizational < Rabarber::Inputs::Context
-        def resolve
-          result = process
-          return result if result.is_a?(Symbol) || result.is_a?(Proc)
-
-          super
-        end
-
         private
 
+        def default_message = "Expected a Class, an instance of ActiveRecord model, a symbol, a string, or a proc, got `#{@value.inspect}`"
+
         def validate_and_normalize
           return @value if @value.is_a?(Proc)
           return @value.to_sym if (@value.is_a?(String) || @value.is_a?(Symbol)) && @value.present?

data/lib/rabarber/inputs/dynamic_rule.rb

@@ -5,10 +5,12 @@ module Rabarber
     class DynamicRule < Rabarber::Inputs::Base
       private
 
+      def default_message = "Expected a symbol, a string, or a proc, got `#{@value.inspect}`"
+
       def validate_and_normalize
         return @value if @value.is_a?(Proc)
 
-        Rabarber::Inputs::NonEmptySymbol.new(@value, error: @error, message: @message).process
+        Rabarber::Inputs::NonEmptySymbol.new(@value, error: @error || default_error, message: @message || default_message).process
       end
     end
   end

data/lib/rabarber/inputs/non_empty_string.rb

@@ -5,6 +5,8 @@ module Rabarber
     class NonEmptyString < Rabarber::Inputs::Base
       private
 
+      def default_message = "Expected a non-empty string, got `#{@value.inspect}`"
+
       def validate_and_normalize
         @value.is_a?(String) && @value.present? ? @value : raise_error
       end

data/lib/rabarber/inputs/non_empty_symbol.rb

@@ -5,6 +5,8 @@ module Rabarber
     class NonEmptySymbol < Rabarber::Inputs::Base
       private
 
+      def default_message = "Expected a symbol or a string, got `#{@value.inspect}`"
+
       def validate_and_normalize
         raise_error unless (@value.is_a?(String) || @value.is_a?(Symbol)) && @value.present?
 

data/lib/rabarber/inputs/role.rb

@@ -5,6 +5,8 @@ module Rabarber
     class Role < Rabarber::Inputs::Base
       private
 
+      def default_message = "Expected a symbol or a string containing only lowercase letters, numbers, and underscores, got `#{@value.inspect}`"
+
       def validate_and_normalize
         raise_error unless (@value.is_a?(String) || @value.is_a?(Symbol)) && @value.to_s.match?(/\A[a-z0-9_]+\z/)
 

data/lib/rabarber/inputs/roles.rb

@@ -5,9 +5,11 @@ module Rabarber
     class Roles < Rabarber::Inputs::Base
       private
 
+      def default_message = "Expected an array of symbols or strings containing only lowercase letters, numbers, and underscores, got `#{@value.inspect}`"
+
       def validate_and_normalize
         Array(@value).map do |role|
-          Rabarber::Inputs::Role.new(role, error: @error, message: @message).process
+          Rabarber::Inputs::Role.new(role, error: @error || default_error, message: @message || default_message).process
         end
       end
     end

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

@@ -9,113 +9,105 @@ module Rabarber
 
       @@included = name
 
-      has_and_belongs_to_many :rabarber_roles, class_name: "Rabarber::Role",
-                                               foreign_key: "roleable_id",
-                                               join_table: "rabarber_roles_roleables"
+      has_many :rabarber_role_assignments, class_name: "Rabarber::RoleAssignment", foreign_key: "roleable_id", inverse_of: :roleable, dependent: :delete_all
+      has_many :rabarber_roles, through: :rabarber_role_assignments, source: :role
 
       scope :with_role, -> (*role_names, context: nil) {
         joins(:rabarber_roles).where(
-          rabarber_roles: { name: process_role_names(role_names), **process_context(context) }
+          rabarber_roles: { name: Rabarber::Inputs::Roles.new(role_names).process, **Rabarber::Inputs::Context.new(context).resolve }
         ).distinct
       }
-
-      class << self
-        def process_role_names(role_names)
-          Rabarber::Inputs::Roles.new(
-            role_names,
-            message: "Expected an array of symbols or strings containing only lowercase letters, numbers, and underscores, got #{role_names.inspect}"
-          ).process
-        end
-
-        def process_context(context)
-          Rabarber::Inputs::Context.new(
-            context,
-            error: Rabarber::InvalidContextError,
-            message: "Expected an instance of ActiveRecord model, a Class, or nil, got #{context.inspect}"
-          ).resolve
-        end
-      end
-      delegate :process_role_names, :process_context, to: :class, private: true
     end
 
     def roles(context: nil)
-      processed_context = process_context(context)
-      Rabarber::Core::Cache.fetch(roleable_id, processed_context) { rabarber_roles.list(context: processed_context) }
+      cached_roles(Rabarber::Inputs::Context.new(context).resolve)
     end
 
     def all_roles
-      Rabarber::Core::Cache.fetch(roleable_id, :all) { rabarber_roles.list_all }
+      Rabarber::Core::Cache.fetch(id, :all) { assigned_roles.list_all }
     end
 
     def has_role?(*role_names, context: nil)
-      processed_context = process_context(context)
-      processed_roles = process_role_names(role_names)
-      roles(context: processed_context).intersect?(processed_roles)
+      processed_context = Rabarber::Inputs::Context.new(context).resolve
+      processed_roles = Rabarber::Inputs::Roles.new(role_names).process
+      cached_roles(processed_context).intersect?(processed_roles)
     end
 
     def assign_roles(*role_names, context: nil, create_new: true)
-      processed_role_names = process_role_names(role_names)
-      processed_context = process_context(context)
+      processed_create_new = Rabarber::Inputs::Boolean.new(create_new).process
+      warn_if_unsaved_roleable(:assign_roles)
 
-      create_new_roles(processed_role_names, context: processed_context) if create_new
+      processed_role_names = Rabarber::Inputs::Roles.new(role_names).process
+      processed_context = Rabarber::Inputs::Context.new(context).resolve
 
-      roles_to_assign = Rabarber::Role.where(
-        name: (processed_role_names - rabarber_roles.list(context: processed_context)), **processed_context
-      )
+      Rabarber::Role.register_missing(processed_role_names, processed_context) if processed_create_new
+
+      role_ids = Rabarber::Role.where(
+        name: (processed_role_names - assigned_roles.names_in(processed_context)), **processed_context
+      ).ids
 
-      if roles_to_assign.any?
-        begin
-          rabarber_roles << roles_to_assign
-        rescue ActiveRecord::RecordNotUnique
+      if role_ids.any?
+        if persisted?
+          rabarber_role_assignments.insert_all(role_ids.map { { role_id: _1 } })
           rabarber_roles.reset
+        else
+          rabarber_roles << Rabarber::Role.where(id: role_ids)
         end
         delete_roleable_cache(contexts: [processed_context])
       end
 
-      roles(context: processed_context)
+      cached_roles(processed_context)
     end
 
     def revoke_roles(*role_names, context: nil)
-      processed_role_names = process_role_names(role_names)
-      processed_context = process_context(context)
+      warn_if_unsaved_roleable(:revoke_roles)
 
-      roles_to_revoke = Rabarber::Role.where(
-        name: processed_role_names.intersection(rabarber_roles.list(context: processed_context)), **processed_context
-      )
+      processed_role_names = Rabarber::Inputs::Roles.new(role_names).process
+      processed_context = Rabarber::Inputs::Context.new(context).resolve
 
-      if roles_to_revoke.any?
-        self.rabarber_roles -= roles_to_revoke
+      if rabarber_role_assignments.where(role: Rabarber::Role.where(name: processed_role_names, **processed_context)).delete_all.positive?
+        rabarber_roles.reset
         delete_roleable_cache(contexts: [processed_context])
       end
 
-      roles(context: processed_context)
+      cached_roles(processed_context)
     end
 
     def revoke_all_roles
-      return [] if rabarber_roles.none?
+      warn_if_unsaved_roleable(:revoke_all_roles)
 
-      contexts = all_roles.keys.map { process_context(_1) }
+      roles = assigned_roles.pluck(:id, :context_type, :context_id)
 
-      rabarber_roles.clear
+      rabarber_role_assignments.where(role_id: roles.map(&:first)).delete_all
+      rabarber_role_assignments.reset
+      rabarber_roles.reset
 
-      delete_roleable_cache(contexts:)
+      delete_roleable_cache(contexts: roles.map { |_, context_type, context_id| { context_type:, context_id: } }.uniq) if roles.any?
 
       []
     end
 
     private
 
-    def create_new_roles(role_names, context:)
-      new_roles = role_names - Rabarber.roles(context:)
-      new_roles.each { |role_name| Rabarber::Role.register(role_name, context:) }
+    def warn_if_unsaved_roleable(method_name)
+      return unless new_record?
+
+      Rabarber.deprecator.warn(
+        "Calling ##{method_name} on an unsaved record is deprecated. Save the record before managing roles.",
+        caller_locations(2)
+      )
     end
 
-    def delete_roleable_cache(contexts:)
-      Rabarber::Core::Cache.delete(*contexts.map { [roleable_id, _1] }, [roleable_id, :all])
+    def assigned_roles
+      Rabarber::Role.where(id: rabarber_role_assignments.select(:role_id))
     end
 
-    def roleable_id
-      public_send(self.class.primary_key)
+    def cached_roles(processed_context)
+      Rabarber::Core::Cache.fetch(id, processed_context) { assigned_roles.names_in(processed_context) }
+    end
+
+    def delete_roleable_cache(contexts:)
+      Rabarber::Core::Cache.delete(*contexts.map { [id, _1] }, [id, :all])
     end
   end
 end

data/lib/rabarber/models/role_management.rb

@@ -1,12 +1,18 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/module/deprecation"
+
 module Rabarber
   module RoleManagement
     def roles(context: nil) = Rabarber::Role.list(context:)
     def all_roles = Rabarber::Role.list_all
-    def create_role(name, context: nil) = Rabarber::Role.register(name, context:)
+    def create_role(name, context: nil) = Rabarber::Role.deprecated_register(name, context:)
+    def create_roles(*names, context: nil) = Rabarber::Role.register(names, context:)
     def rename_role(old_name, new_name, context: nil, force: false) = Rabarber::Role.amend(old_name, new_name, context:, force:)
-    def delete_role(name, context: nil, force: false) = Rabarber::Role.drop(name, context:, force:)
+    def delete_role(name, context: nil, force: false) = Rabarber::Role.deprecated_drop(name, context:, force:)
+    def delete_roles(*names, context: nil, force: false) = Rabarber::Role.drop(names, context:, force:)
     def prune = Rabarber::Role.prune # rubocop:disable Rails/Delegate
+
+    deprecate create_role: :create_roles, delete_role: :delete_roles, deprecator: Rabarber.deprecator
   end
 end

data/lib/rabarber/version.rb

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

data/lib/rabarber.rb

@@ -25,6 +25,12 @@ module Rabarber
   class InvalidContextError < Rabarber::InvalidArgumentError; end
   class NotFoundError < Rabarber::Error; end
 
+  DEPRECATOR = ActiveSupport::Deprecation.new("7.0", "Rabarber")
+
+  def self.deprecator
+    DEPRECATOR
+  end
+
   delegate :configure, to: Rabarber::Configuration
   module_function :configure
 end
@@ -37,11 +43,10 @@ require_relative "rabarber/controllers/concerns/authorization"
 require_relative "rabarber/helpers/helpers"
 require_relative "rabarber/helpers/migration_helpers"
 require_relative "rabarber/models/concerns/roleable"
-require_relative "rabarber/models/role"
 require_relative "rabarber/models/role_management"
 
 Rabarber.extend Rabarber::RoleManagement
 
 require_relative "rabarber/core/permissions"
 
-require_relative "rabarber/railtie"
+require_relative "rabarber/engine"

data/rabarber.gemspec

@@ -7,14 +7,13 @@ Gem::Specification.new do |spec|
   spec.version = Rabarber::VERSION
   spec.authors = ["enjaku4", "trafium"]
   spec.email = ["contact@brownbox.dev"]
-  spec.homepage = "https://github.com/enjaku4/rabarber"
+  spec.homepage = "https://github.com/brownboxdev/rabarber-authorization"
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
   spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
   spec.metadata["documentation_uri"] = "#{spec.homepage}/blob/main/README.md"
   spec.metadata["mailing_list_uri"] = "#{spec.homepage}/discussions"
-  spec.metadata["funding_uri"] = "https://github.com/sponsors/enjaku4"
   spec.metadata["rubygems_mfa_required"] = "true"
   spec.summary = "Simple role-based authorization library for Ruby on Rails"
   spec.description = "Simple role-based authorization for Rails applications with multi-tenancy support"
@@ -23,7 +22,7 @@ Gem::Specification.new do |spec|
 
   spec.files = [
     "rabarber.gemspec", "README.md", "CHANGELOG.md", "LICENSE.txt"
-  ] + Dir.glob("lib/**/*")
+  ] + Dir.glob("{app,lib}/**/*")
 
   spec.require_paths = ["lib"]
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rabarber
 version: !ruby/object:Gem::Version
-  version: 6.0.2
+  version: 6.1.0
 platform: ruby
 authors:
 - enjaku4
 - trafium
 bindir: bin
 cert_chain: []
-date: 2026-07-19 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -41,6 +41,8 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- app/models/rabarber/role.rb
+- app/models/rabarber/role_assignment.rb
 - lib/generators/rabarber/roles_generator.rb
 - lib/generators/rabarber/templates/create_rabarber_roles.rb.erb
 - lib/rabarber.rb
@@ -51,6 +53,7 @@ files:
 - lib/rabarber/core/permissions.rb
 - lib/rabarber/core/roleable.rb
 - lib/rabarber/core/rule.rb
+- lib/rabarber/engine.rb
 - lib/rabarber/helpers/helpers.rb
 - lib/rabarber/helpers/migration_helpers.rb
 - lib/rabarber/inputs/base.rb
@@ -64,22 +67,19 @@ files:
 - lib/rabarber/inputs/role.rb
 - lib/rabarber/inputs/roles.rb
 - lib/rabarber/models/concerns/roleable.rb
-- lib/rabarber/models/role.rb
 - lib/rabarber/models/role_management.rb
-- lib/rabarber/railtie.rb
 - lib/rabarber/version.rb
 - rabarber.gemspec
-homepage: https://github.com/enjaku4/rabarber
+homepage: https://github.com/brownboxdev/rabarber-authorization
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/enjaku4/rabarber
-  source_code_uri: https://github.com/enjaku4/rabarber
-  changelog_uri: https://github.com/enjaku4/rabarber/blob/main/CHANGELOG.md
-  bug_tracker_uri: https://github.com/enjaku4/rabarber/issues
-  documentation_uri: https://github.com/enjaku4/rabarber/blob/main/README.md
-  mailing_list_uri: https://github.com/enjaku4/rabarber/discussions
-  funding_uri: https://github.com/sponsors/enjaku4
+  homepage_uri: https://github.com/brownboxdev/rabarber-authorization
+  source_code_uri: https://github.com/brownboxdev/rabarber-authorization
+  changelog_uri: https://github.com/brownboxdev/rabarber-authorization/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/brownboxdev/rabarber-authorization/issues
+  documentation_uri: https://github.com/brownboxdev/rabarber-authorization/blob/main/README.md
+  mailing_list_uri: https://github.com/brownboxdev/rabarber-authorization/discussions
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.15
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Simple role-based authorization library for Ruby on Rails
 test_files: []

data/lib/rabarber/models/role.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Rabarber
-  class Role < ActiveRecord::Base
-    self.table_name = "rabarber_roles"
-
-    belongs_to :context, polymorphic: true, optional: true
-
-    class << self
-      def list(context: nil)
-        where(process_context(context)).pluck(:name).map(&:to_sym)
-      end
-
-      def list_all
-        includes(:context).each_with_object({}) do |role, hash|
-          (hash[role.context] ||= []) << role.name.to_sym
-        rescue ActiveRecord::RecordNotFound
-          next
-        end
-      rescue NameError => e
-        raise Rabarber::NotFoundError, "Context not found: class #{e.name} may have been renamed or deleted"
-      end
-
-      def register(name, context: nil)
-        name = process_role_name(name)
-        processed_context = process_context(context)
-
-        return false if exists?(name:, **processed_context)
-
-        !!create!(name:, **processed_context)
-      rescue ActiveRecord::RecordNotUnique
-        false
-      end
-
-      def amend(old_name, new_name, context: nil, force: false)
-        processed_context = process_context(context)
-        role = find_by(name: process_role_name(old_name), **processed_context)
-
-        raise Rabarber::NotFoundError, "Role not found" unless role
-
-        name = process_role_name(new_name)
-
-        return false if exists?(name:, **processed_context) || role.roleables.exists? && !force
-
-        role.update!(name:)
-
-        delete_roleables_cache(role.roleables.pluck(:id), context: processed_context)
-
-        true
-      rescue ActiveRecord::RecordNotUnique
-        false
-      end
-
-      def drop(name, context: nil, force: false)
-        processed_context = process_context(context)
-        role = find_by(name: process_role_name(name), **processed_context)
-
-        raise Rabarber::NotFoundError, "Role not found" unless role
-
-        return false if role.roleables.exists? && !force
-
-        roleable_ids = role.roleables.pluck(:id)
-
-        role.destroy!
-
-        delete_roleables_cache(roleable_ids, context: processed_context)
-
-        true
-      end
-
-      def prune
-        orphaned_roles = where.not(context_id: nil).includes(:context).filter_map do |role|
-          !role.context
-        rescue ActiveRecord::RecordNotFound
-          role.id
-        end
-
-        return if orphaned_roles.empty?
-
-        ActiveRecord::Base.transaction do
-          ActiveRecord::Base.connection.execute(
-            ActiveRecord::Base.sanitize_sql(
-              ["DELETE FROM rabarber_roles_roleables WHERE role_id IN (?)", orphaned_roles]
-            )
-          )
-          where(id: orphaned_roles).delete_all
-        end
-
-        Rabarber::Core::Cache.clear
-      end
-
-      private
-
-      def delete_roleables_cache(roleable_ids, context:)
-        Rabarber::Core::Cache.delete(*roleable_ids.flat_map { [[_1, context], [_1, :all]] })
-      end
-
-      def process_role_name(name)
-        Rabarber::Inputs::Role.new(
-          name,
-          message: "Expected a symbol or a string containing only lowercase letters, numbers, and underscores, got #{name.inspect}"
-        ).process
-      end
-
-      def process_context(context)
-        Rabarber::Inputs::Context.new(
-          context,
-          error: Rabarber::InvalidContextError,
-          message: "Expected an instance of ActiveRecord model, a Class, or nil, got #{context.inspect}"
-        ).resolve
-      end
-    end
-
-    def context
-      return context_type.constantize if context_type.present? && context_id.blank?
-
-      record = super
-
-      raise ActiveRecord::RecordNotFound.new(nil, context_type, nil, context_id) if context_id.present? && !record
-
-      record
-    end
-  end
-end