mini-fast-sys 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4c2167e9be76b62ce0098ca3f4f7662a41765b79365512e9cb075b58383a5260
+  data.tar.gz: 4f0abd952227a08b1369b6c856ee028be2eeff65ce6233bec2892cb5a36c322d
+SHA512:
+  metadata.gz: 5d5fc22aee1fe1e969b5111b4d63fbb83d0a7518a92c8072ecc7b2f0244fb133f6eba1decb2aab174faa4cf40678e2b82c04869009f9b752ab5c8dfbd484e111
+  data.tar.gz: 73087d9243d7df47181cd281ed17582d2774008a6a71e425202ceec8d94a90f352e5ae6ab19ad8d674a9f347f8863bc36c0d75fbe05ed726510f403da3a03731

data/mini-fast-sys.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "mini-fast-sys"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on ransack"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+  s.metadata    = { "source_code_uri" => "https://github.com/Andrey78/mini-fast-sys" }
+end

data/ransack-4.4.1/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Ernie Miller
+
+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/ransack-4.4.1/README.md

@@ -0,0 +1,101 @@
+# ![Ransack](./docs/static/logo/ransack-h.png "Ransack")
+
+[![Build Status](https://github.com/activerecord-hackery/ransack/workflows/test/badge.svg)](https://github.com/activerecord-hackery/ransack/actions)
+[![Gem Version](https://badge.fury.io/rb/ransack.svg)](http://badge.fury.io/rb/ransack)
+[![Code Climate](https://codeclimate.com/github/activerecord-hackery/ransack/badges/gpa.svg)](https://codeclimate.com/github/activerecord-hackery/ransack)
+[![Backers on Open Collective](https://opencollective.com/ransack/backers/badge.svg)](#backers) [![Sponsors on Open Collective](https://opencollective.com/ransack/sponsors/badge.svg)](#sponsors)
+
+# Introduction
+
+Ransack will help you easily add **searching to your Rails application**, without any additional dependencies.
+
+There are advanced searching solutions around, like ElasticSearch or Algolia. **Ransack** will do the job for many Rails websites, without the need to run additional infrastructure or work in a different language. With Ransack you do it all with standard Ruby and ERB.
+
+Ready to move beyond the basics? Use **advanced features** like i18n and extensive configuration options.
+
+Ransack is supported for Rails 8.0, 7.2 on Ruby 3.1 and later.
+
+## Installation
+
+To install `ransack` and add it to your Gemfile, run
+
+```ruby title='Gemfile'
+gem 'ransack'
+```
+
+### Bleeding edge
+
+If you would like to use the latest updates not yet published to RubyGems, use the `main` branch:
+
+```ruby title='Gemfile'
+gem 'ransack', :github => 'activerecord-hackery/ransack', :branch => 'main'
+```
+
+### Documentation
+
+There is [extensive documentation on Ransack](https://activerecord-hackery.github.io/ransack/), which is a [Docusaurus](https://docusaurus.io/) project and run as a GitHub Pages site. Alternatively there is [AI Generated documentation](https://deepwiki.com/activerecord-hackery/ransack/1-overview) produced by [devin.ai](https://devin.ai/).
+
+This [gist](https://gist.github.com/raghubetina/d5fc3df67ddbadcac271) has a quick-start cheatsheet, created by [@raghubetina](https://gist.github.com/raghubetina)
+
+## Issue tracker
+
+* Before filing an issue, please read the [Contributing Guide](CONTRIBUTING.md).
+* File an issue if a bug is caused by Ransack, is new (has not already been reported), and _can be reproduced from the information you provide_.
+* Please consider creating a pull request with a failing test that demonstrates the problem.
+* Contributions are welcome. :smiley:
+* Please do not use the issue tracker for personal support requests. Stack Overflow or [GitHub Discussions](https://github.com/activerecord-hackery/ransack/discussions) is a better place for that where a wider community can help you!
+
+
+## Contributions
+
+To support the project:
+
+* Consider supporting us via [Open Collective](https://opencollective.com/ransack/backers/badge.svg)
+* Use Ransack in your apps, and let us know if you encounter anything that's
+broken or missing. A failing spec to demonstrate the issue is awesome. A pull
+request with passing tests is even better!
+* Before filing an issue or pull request, be sure to read and follow the
+[Contributing Guide](CONTRIBUTING.md).
+* Please use Stack Overflow or [GitHub Discussions](https://github.com/activerecord-hackery/ransack/discussions) for questions or discussion not
+directly related to bug reports, pull requests, or documentation improvements.
+* Spread the word on social media if Ransack's been useful
+to you. The more people who are using the project, the quicker we can find and
+fix bugs!
+
+## Contributors
+
+Ransack was created by [Ernie Miller](http://twitter.com/erniemiller) and is developed and maintained by:
+* [Sean Carroll](https://github.com/scarroll32)
+* [Deivid Rodriguez](https://github.com/deivid-rodriguez)
+* [Greg Molnar](https://github.com/gregmolnar)
+* [A great group of contributors](https://github.com/activerecord-hackery/ransack/graphs/contributors).
+- Ransack's logo is designed by [Anıl Kılıç](https://github.com/anilkilic).
+
+Alumni Maintainers
+- [Jon Atack](http://twitter.com/jonatack)
+- [Ryan Bigg](http://twitter.com/ryanbigg)
+
+This project exists thanks to all the people who contribute. <img src="https://opencollective.com/ransack/contributors.svg?width=890&button=false" />
+
+
+## Backers
+
+Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/ransack#backer)]
+
+<a href="https://opencollective.com/ransack#backers" target="_blank"><img src="https://opencollective.com/ransack/backers.svg?width=890" /></a>
+
+
+## Sponsors
+
+Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/ransack#sponsor)]
+
+<a href="https://opencollective.com/ransack/sponsor/0/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/0/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/1/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/1/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/2/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/2/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/3/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/3/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/4/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/4/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/5/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/5/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/6/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/6/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/7/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/7/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/8/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/8/avatar.svg" /></a>
+<a href="https://opencollective.com/ransack/sponsor/9/website" target="_blank"><img src="https://opencollective.com/ransack/sponsor/9/avatar.svg" /></a>

data/ransack-4.4.1/lib/polyamorous/activerecord/join_association.rb

@@ -0,0 +1,70 @@
+module Polyamorous
+  module JoinAssociationExtensions
+    include SwappingReflectionClass
+    def self.prepended(base)
+      base.class_eval { attr_reader :join_type }
+    end
+
+    def initialize(reflection, children, polymorphic_class = nil, join_type = Arel::Nodes::InnerJoin)
+      @join_type = join_type
+      if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
+        swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
+          super(reflection, children)
+          self.reflection.options[:polymorphic] = true
+        end
+      else
+        super(reflection, children)
+      end
+    end
+
+    # Same as #join_constraints, but instead of constructing tables from the
+    # given block, uses the ones passed
+    def join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables)
+      joins = []
+      chain = []
+
+      reflection.chain.each.with_index do |reflection, i|
+        table = tables[i]
+
+        @table ||= table
+        chain << [reflection, table]
+      end
+
+      # The chain starts with the target table, but we want to end with it here (makes
+      # more sense in this context), so we reverse
+      chain.reverse_each do |reflection, table|
+        klass = reflection.klass
+
+        join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
+
+        unless join_scope.references_values.empty?
+          join_dependency = join_scope.construct_join_dependency(
+            join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
+          )
+          join_scope.joins!(join_dependency)
+        end
+
+        arel = join_scope.arel(alias_tracker.aliases)
+        nodes = arel.constraints.first
+
+        if nodes.is_a?(Arel::Nodes::And)
+          others = nodes.children.extract! do |node|
+            !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+          end
+        end
+
+        joins << table.create_join(table, table.create_on(nodes), join_type)
+
+        if others && !others.empty?
+          joins.concat arel.join_sources
+          append_constraints(joins.last, others)
+        end
+
+        # The current table in this iteration becomes the foreign table in the next
+        foreign_table, foreign_klass = table, klass
+      end
+
+      joins
+    end
+  end
+end

data/ransack-4.4.1/lib/polyamorous/activerecord/join_association_7_2.rb

@@ -0,0 +1,55 @@
+module Polyamorous
+  module JoinAssociationExtensions
+    # Same as #join_constraints, but instead of constructing tables from the
+    # given block, uses the ones passed
+    def join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables)
+      joins = []
+      chain = []
+
+      reflection.chain.each.with_index do |reflection, i|
+        table = tables[i]
+
+        @table ||= table
+        chain << [reflection, table]
+      end
+
+      base_klass.with_connection do |connection|
+        # The chain starts with the target table, but we want to end with it here (makes
+        # more sense in this context), so we reverse
+        chain.reverse_each do |reflection, table|
+          klass = reflection.klass
+
+          join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
+
+          unless join_scope.references_values.empty?
+            join_dependency = join_scope.construct_join_dependency(
+              join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
+            )
+            join_scope.joins!(join_dependency)
+          end
+
+          arel = join_scope.arel(alias_tracker.aliases)
+          nodes = arel.constraints.first
+
+          if nodes.is_a?(Arel::Nodes::And)
+            others = nodes.children.extract! do |node|
+              !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+            end
+          end
+
+          joins << table.create_join(table, table.create_on(nodes), join_type)
+
+          if others && !others.empty?
+            joins.concat arel.join_sources
+            append_constraints(connection, joins.last, others)
+          end
+
+          # The current table in this iteration becomes the foreign table in the next
+          foreign_table, foreign_klass = table, klass
+        end
+
+        joins
+      end
+    end
+  end
+end

data/ransack-4.4.1/lib/polyamorous/activerecord/join_dependency.rb

@@ -0,0 +1,102 @@
+module Polyamorous
+  module JoinDependencyExtensions
+    # Replaces ActiveRecord::Associations::JoinDependency#build
+    def build(associations, base_klass)
+      associations.map do |name, right|
+        if name.is_a? Join
+          reflection = find_reflection base_klass, name.name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          klass = if reflection.polymorphic?
+            name.klass || base_klass
+          else
+            reflection.klass
+          end
+          JoinAssociation.new(reflection, build(right, klass), name.klass, name.type)
+        else
+          reflection = find_reflection base_klass, name
+          reflection.check_validity!
+          reflection.check_eager_loadable!
+
+          if reflection.polymorphic?
+            raise ActiveRecord::EagerLoadPolymorphicError.new(reflection)
+          end
+          JoinAssociation.new(reflection, build(right, reflection.klass))
+        end
+      end
+    end
+
+    def join_constraints(joins_to_add, alias_tracker, references)
+      @alias_tracker = alias_tracker
+      @joined_tables = {}
+      @references = {}
+
+      references.each do |table_name|
+        @references[table_name.to_sym] = table_name if table_name.is_a?(String)
+      end
+
+      joins = make_join_constraints(join_root, join_type)
+
+      joins.concat joins_to_add.flat_map { |oj|
+        if join_root.match?(oj.join_root) && join_root.table.name == oj.join_root.table.name
+          walk join_root, oj.join_root, oj.join_type
+        else
+          make_join_constraints(oj.join_root, oj.join_type)
+        end
+      }
+    end
+
+    def construct_tables_for_association!(join_root, association)
+      tables = table_aliases_for(join_root, association)
+      association.table = tables.first
+      tables
+    end
+
+    private
+
+    def table_aliases_for(parent, node)
+      @joined_tables ||= {}
+      node.reflection.chain.map { |reflection|
+        table, terminated = @joined_tables[reflection]
+        root = reflection == node.reflection
+
+        if table && (!root || !terminated)
+          @joined_tables[reflection] = [table, true] if root
+          table
+        else
+          table = alias_tracker.aliased_table_for(reflection.klass.arel_table) do
+            name = reflection.alias_candidate(parent.table_name)
+            root ? name : "#{name}_join"
+          end
+          @joined_tables[reflection] ||= [table, root] if join_type == Arel::Nodes::OuterJoin
+          table
+        end
+      }
+    end
+
+    module ClassMethods
+      # Prepended before ActiveRecord::Associations::JoinDependency#walk_tree
+      #
+      def walk_tree(associations, hash)
+        case associations
+        when TreeNode
+          associations.add_to_tree(hash)
+        when Hash
+          associations.each do |k, v|
+            cache =
+              if TreeNode === k
+                k.add_to_tree(hash)
+              else
+                hash[k] ||= {}
+              end
+            walk_tree(v, cache)
+          end
+        else
+          super(associations, hash)
+        end
+      end
+    end
+
+  end
+end

data/ransack-4.4.1/lib/polyamorous/activerecord/reflection.rb

@@ -0,0 +1,11 @@
+module Polyamorous
+  module ReflectionExtensions
+    def join_scope(table, foreign_table, foreign_klass)
+     if respond_to?(:polymorphic?) && polymorphic?
+        super.where!(foreign_table[foreign_type].eq(klass.name))
+      else
+        super
+      end
+    end
+  end
+end

data/ransack-4.4.1/lib/polyamorous/join.rb

@@ -0,0 +1,70 @@
+module Polyamorous
+  class Join
+    include TreeNode
+
+    attr_accessor :name
+    attr_reader :type, :klass
+
+    def initialize(name, type = InnerJoin, klass = nil)
+      @name = name
+      @type = convert_to_arel_join_type(type)
+      @klass = convert_to_class(klass) if klass
+    end
+
+    def klass=(klass)
+      @klass = convert_to_class(klass) if klass
+    end
+
+    def type=(type)
+      @type = convert_to_arel_join_type(type) if type
+    end
+
+    def hash
+      [@name, @type, @klass].hash
+    end
+
+    def eql?(other)
+      self.class == other.class &&
+      self.name  == other.name &&
+      self.type  == other.type &&
+      self.klass == other.klass
+    end
+
+    alias :== :eql?
+
+    def add_to_tree(hash)
+      hash[self] ||= {}
+    end
+
+    private
+
+    def convert_to_arel_join_type(type)
+      case type
+      when 'inner', :inner
+        InnerJoin
+      when 'outer', :outer
+        OuterJoin
+      when Class
+        if [InnerJoin, OuterJoin].include? type
+          type
+        else
+          raise ArgumentError, "#{type} cannot be converted to an ARel join type"
+        end
+      else
+        raise ArgumentError, "#{type} cannot be converted to an ARel join type"
+      end
+    end
+
+    def convert_to_class(value)
+      case value
+      when String, Symbol
+        Kernel.const_get(value)
+      when Class
+        value
+      else
+        raise ArgumentError, "#{value} cannot be converted to a Class"
+      end
+    end
+
+  end
+end

data/ransack-4.4.1/lib/polyamorous/polyamorous.rb

@@ -0,0 +1,27 @@
+ActiveSupport.on_load(:active_record) do
+  module Polyamorous
+    InnerJoin = Arel::Nodes::InnerJoin
+    OuterJoin = Arel::Nodes::OuterJoin
+
+    JoinDependency  = ::ActiveRecord::Associations::JoinDependency
+    JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+  end
+
+  require 'polyamorous/tree_node'
+  require 'polyamorous/join'
+  require 'polyamorous/swapping_reflection_class'
+
+  require 'polyamorous/activerecord/join_association'
+  require 'polyamorous/activerecord/join_dependency'
+  require 'polyamorous/activerecord/reflection'
+
+  if ::ActiveRecord.version >= ::Gem::Version.new("7.2") && ::ActiveRecord.version < ::Gem::Version.new("7.2.2.1")
+    require "polyamorous/activerecord/join_association_7_2"
+  end
+
+  ActiveRecord::Reflection::AbstractReflection.send(:prepend, Polyamorous::ReflectionExtensions)
+
+  Polyamorous::JoinDependency.send(:prepend, Polyamorous::JoinDependencyExtensions)
+  Polyamorous::JoinDependency.singleton_class.send(:prepend, Polyamorous::JoinDependencyExtensions::ClassMethods)
+  Polyamorous::JoinAssociation.send(:prepend, Polyamorous::JoinAssociationExtensions)
+end

data/ransack-4.4.1/lib/polyamorous/swapping_reflection_class.rb

@@ -0,0 +1,11 @@
+module Polyamorous
+  module SwappingReflectionClass
+    def swapping_reflection_klass(reflection, klass)
+      new_reflection = reflection.clone
+      new_reflection.instance_variable_set(:@options, reflection.options.clone)
+      new_reflection.options.delete(:polymorphic)
+      new_reflection.instance_variable_set(:@klass, klass)
+      yield new_reflection
+    end
+  end
+end

data/ransack-4.4.1/lib/polyamorous/tree_node.rb

@@ -0,0 +1,7 @@
+module Polyamorous
+  module TreeNode
+    def add_to_tree(hash)
+      raise NotImplementedError
+    end
+  end
+end

data/ransack-4.4.1/lib/ransack/active_record.rb

@@ -0,0 +1,14 @@
+require 'ransack/adapters/active_record/base'
+
+ActiveSupport.on_load(:active_record) do
+  extend Ransack::Adapters::ActiveRecord::Base
+
+  Ransack::SUPPORTS_ATTRIBUTE_ALIAS =
+  begin
+    ActiveRecord::Base.respond_to?(:attribute_aliases)
+  rescue NameError
+    false
+  end
+end
+
+require 'ransack/adapters/active_record/context'

data/ransack-4.4.1/lib/ransack/adapters/active_record/base.rb

@@ -0,0 +1,152 @@
+module Ransack
+  module Adapters
+    module ActiveRecord
+      module Base
+
+        def self.extended(base)
+          base.class_eval do
+            class_attribute :_ransackers
+            class_attribute :_ransack_aliases
+            self._ransackers ||= {}
+            self._ransack_aliases ||= {}
+          end
+        end
+
+        def ransack(params = {}, options = {})
+          Search.new(self, params, options)
+        end
+
+        def ransack!(params = {}, options = {})
+          ransack(params, options.merge(ignore_unknown_conditions: false))
+        end
+
+        def ransacker(name, opts = {}, &block)
+          self._ransackers = _ransackers.merge name.to_s => Ransacker
+            .new(self, name, opts, &block)
+        end
+
+        def ransack_alias(new_name, old_name)
+          self._ransack_aliases = _ransack_aliases.merge new_name.to_s =>
+            old_name.to_s
+        end
+
+        # Ransackable_attributes, by default, returns all column names
+        # and any defined ransackers as an array of strings.
+        # For overriding with a whitelist array of strings.
+        #
+        def ransackable_attributes(auth_object = nil)
+          @ransackable_attributes ||= deprecated_ransackable_list(:ransackable_attributes)
+        end
+
+        # Ransackable_associations, by default, returns the names
+        # of all associations as an array of strings.
+        # For overriding with a whitelist array of strings.
+        #
+        def ransackable_associations(auth_object = nil)
+          @ransackable_associations ||= deprecated_ransackable_list(:ransackable_associations)
+        end
+
+        # Ransortable_attributes, by default, returns the names
+        # of all attributes available for sorting as an array of strings.
+        # For overriding with a whitelist array of strings.
+        #
+        def ransortable_attributes(auth_object = nil)
+          ransackable_attributes(auth_object)
+        end
+
+        # Ransackable_scopes, by default, returns an empty array
+        # i.e. no class methods/scopes are authorized.
+        # For overriding with a whitelist array of *symbols*.
+        #
+        def ransackable_scopes(auth_object = nil)
+          []
+        end
+
+        # ransack_scope_skip_sanitize_args, by default, returns an empty array.
+        # i.e. use the sanitize_scope_args setting to determine if args should be converted.
+        # For overriding with a list of scopes which should be passed the args as-is.
+        #
+        def ransackable_scopes_skip_sanitize_args
+          []
+        end
+
+        # Bare list of all potentially searchable attributes. Searchable attributes
+        # need to be explicitly allowlisted through the `ransackable_attributes`
+        # method in each model, but if you're allowing almost everything to be
+        # searched, this list can be used as a base for exclusions.
+        #
+        def authorizable_ransackable_attributes
+          if Ransack::SUPPORTS_ATTRIBUTE_ALIAS
+            column_names + _ransackers.keys + _ransack_aliases.keys +
+            attribute_aliases.keys
+          else
+            column_names + _ransackers.keys + _ransack_aliases.keys
+          end.uniq
+        end
+
+        # Bare list of all potentially searchable associations. Searchable
+        # associations need to be explicitly allowlisted through the
+        # `ransackable_associations` method in each model, but if you're
+        # allowing almost everything to be searched, this list can be used as a
+        # base for exclusions.
+        #
+        def authorizable_ransackable_associations
+          reflect_on_all_associations.map { |a| a.name.to_s }
+        end
+
+        private
+
+        def deprecated_ransackable_list(method)
+          list_type = method.to_s.delete_prefix("ransackable_")
+
+          if explicitly_defined?(method)
+            warn_deprecated <<~ERROR
+              Ransack's builtin `#{method}` method is deprecated and will result
+              in an error in the future. If you want to authorize the full list
+              of searchable #{list_type} for this model, use
+              `authorizable_#{method}` instead of delegating to `super`.
+            ERROR
+
+            public_send("authorizable_#{method}")
+          else
+            raise <<~MESSAGE
+              Ransack needs #{name} #{list_type} explicitly allowlisted as
+              searchable. Define a `#{method}` class method in your `#{name}`
+              model, watching out for items you DON'T want searchable (for
+              example, `encrypted_password`, `password_reset_token`, `owner` or
+              other sensitive information). You can use the following as a base:
+
+              ```ruby
+              class #{name} < ApplicationRecord
+
+                # ...
+
+                def self.#{method}(auth_object = nil)
+                  #{public_send("authorizable_#{method}").sort.inspect}
+                end
+
+                # ...
+
+              end
+              ```
+            MESSAGE
+          end
+        end
+
+        def explicitly_defined?(method)
+          definer_ancestor = singleton_class.ancestors.find do |ancestor|
+            ancestor.instance_methods(false).include?(method)
+          end
+
+          definer_ancestor != Ransack::Adapters::ActiveRecord::Base
+        end
+
+        def warn_deprecated(message)
+          caller_location = caller_locations.find { |location| !location.path.start_with?(File.expand_path("../..", __dir__)) }
+
+          warn "DEPRECATION WARNING: #{message.squish} (called at #{caller_location.path}:#{caller_location.lineno})"
+        end
+      end
+    end
+  end
+end