modern_searchlogic 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8c1285376c99c453d6e9af0bb21b1458c4f34d5ddd7cdec3ce4e14ceae3d5d6b
+  data.tar.gz: bce4a074d01473a88767f1ef8b11c77c8a127272a6dbd6907dc0d8977d489796
+SHA512:
+  metadata.gz: 8dbd45af5b7a11758a6e3323b62697f746e275033cbc492c669967fb9c570a3c2d805682c1635eff6d49d91a9302812dc9e879eb824322a6372164588d8968b9
+  data.tar.gz: d68579d00786da93e3db22cfafeecc5440455f4e3f4a90e38ed7c5eb712ccac63a1123fabe22281e9bcb61355d11b5fe19903ec1a1bdf986cf8882559c66aebf

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Andrew Warner
+
+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/README.md

@@ -0,0 +1,45 @@
+# ModernSearchlogic
+
+Searchlogic for Rails 3+!
+
+Note: this is a fork of [Genius/modern_searchlogic](https://github.com/Genius/modern_searchlogic).
+Unlike upstream, this repository is published to RubyGems (and has versioning).
+
+## Supported Versions
+
+The Gem is tested on Rails 3-8 (except 6, because I'm lazy), using the latest version available.
+For the older versions, it uses Rails LTS so we don't need to maintain Ruby 3 patches here as well.
+
+The gem *might* work on Ruby 2, but it is only tested against Ruby 3.3.
+
+## Usage
+
+Just add the Gem to your gemspec, and the searchlogic methods will be available.
+Refer to the searchlogic documentation for more details.
+
+## Contributing
+
+Optional, but required for running specs against Rails 3-5: a [Rails LTS](https://railslts.com) subscription.
+If you do have one, create a `.bundle/config` with contents:
+
+```yaml
+---
+BUNDLE_GEMS__RAILSLTS__COM: "theusername:thepassword"
+```
+
+- Install Ruby 3.3
+- Run `bundler install`
+- If you DON'T have a Rails LTS subscription, comment out the Rails 3-5 appraisals in the `Appraisal` file
+- Run `bundler exec appraisal install`
+- Start the database. You can use Docker compose to do this the easy way. If you go the manual route, make sure authentication is optional
+- You are now ready!
+
+## Running Specs
+
+```shell
+# Run for ALL Rails versions:
+$ bundle exec rake test
+
+# OR for a specific Rails version only (replace 7 with the major version of Rails):
+$ bundle exec rake rspec7
+```

data/Rakefile

@@ -0,0 +1,122 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'pathname'
+
+SUPPORTED_RAILS_VERSIONS = (3..8).to_a.filter { |it| it != 6 }
+
+def convert_appraisal_to_gemfile(appraisal_name)
+  appraisal_name.tr('-', '_')
+end
+
+def setup_database(gemfile_path, test_app_dir)
+  puts "Setting up database..."
+
+  Dir.chdir(File.join(ENV['PROJECT_ROOT'], test_app_dir)) do
+    sh({ 'BUNDLE_GEMFILE' => gemfile_path }, 'bundle exec rake db:create:all') || exit(1)
+    sh({ 'BUNDLE_GEMFILE' => gemfile_path }, 'bundle exec rake db:environment:set RAILS_ENV=test') || exit(1)
+    sh({ 'BUNDLE_GEMFILE' => gemfile_path }, 'bundle exec rake db:schema:load') || exit(1)
+  end
+end
+
+def find_spec_files
+  Dir.chdir(ENV['PROJECT_ROOT']) do
+    Dir.glob('spec/**/*_spec.rb')
+       .reject { |file| file.match?(/spec\/app_rails.*\//) }
+       .map { |file| File.expand_path(file) }
+  end
+end
+
+def run_specs(gemfile_path, test_app_dir, spec_files)
+  current_rubylib = ENV['RUBYLIB'] || ''
+  spec_path = File.join(ENV['PROJECT_ROOT'], 'spec')
+  ENV['RUBYLIB'] = current_rubylib.empty? ? spec_path : "#{spec_path}:#{current_rubylib}"
+
+  ENV['RAILS_ROOT'] = File.join(ENV['PROJECT_ROOT'], test_app_dir)
+
+  Dir.chdir(File.join(ENV['PROJECT_ROOT'], test_app_dir)) do
+    ruby3_compat = File.join(ENV['PROJECT_ROOT'], 'spec', 'ruby3_compatibility')
+
+    cmd = [
+      'bundle', 'exec', 'ruby',
+      '-r', ruby3_compat,
+      '-e', "require 'rspec/core'; RSpec::Core::Runner.run(ARGV)",
+      *spec_files
+    ]
+
+    sh({ 'BUNDLE_GEMFILE' => gemfile_path }, *cmd) || exit(1)
+  end
+end
+
+def run_specs_for_version(appraisal_name, test_app_dir)
+  ENV['POSTGRES_URL'] ||= 'postgres://postgres:password@localhost:5432/postgres'
+  ENV['RAILS_ENV'] ||= 'test'
+  ENV['PROJECT_ROOT'] ||= `git rev-parse --show-toplevel`.strip
+
+  gemfile_name = convert_appraisal_to_gemfile(appraisal_name)
+  gemfile_path = File.join(ENV['PROJECT_ROOT'], 'gemfiles', "#{gemfile_name}.gemfile")
+
+  puts "Running specs for #{appraisal_name} in #{test_app_dir}"
+  puts "Using gemfile: #{gemfile_name}.gemfile"
+
+  setup_database(gemfile_path, test_app_dir)
+  spec_files = find_spec_files
+  run_specs(gemfile_path, test_app_dir, spec_files)
+  puts "Specs completed for #{appraisal_name}"
+end
+
+SUPPORTED_RAILS_VERSIONS.each do |version|
+  desc "Run specs for Rails #{version}"
+  task :"rspec#{version}" do
+    run_specs_for_version("rails-#{version}", "spec/app_rails#{version}")
+  end
+end
+
+desc 'Run specs for all versions of Rails'
+task :test => SUPPORTED_RAILS_VERSIONS.map { |it| "rspec#{it}".to_sym }
+
+desc 'Install appraisals'
+task :install_appraisals do
+  sh('bundler exec appraisal install')
+end
+
+require 'pathname'
+
+desc 'Set up symlinks for a new Rails version appraisal'
+task :setup_symlinks, [:name] do |_t, args|
+  raise 'Please provide the app name (e.g. app_rails9)' unless args[:name]
+
+  base_dir = Pathname.new("spec/#{args[:name]}")
+  shared_dir = Pathname.new('spec/shared')
+
+  links = [
+    { from: 'app/models', to: 'models' },
+    { from: 'db/migrate', to: 'db/migrate' },
+    { from: 'config/database.yml', to: 'config/database.yml' }
+  ]
+
+  links.each do |link|
+    link_name = base_dir.join(link[:from])
+    target = shared_dir.join(link[:to])
+    parent_dir = link_name.dirname
+    sh("mkdir -p #{parent_dir}")
+    relative_target = target.relative_path_from(parent_dir)
+    sh("ln -sf #{relative_target} #{link_name}")
+  end
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'ModernSearchlogic'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/lib/modern_searchlogic/active_record_methods.rb

@@ -0,0 +1,23 @@
+require_relative 'default_scoping'
+require_relative 'scope_tracking'
+require_relative 'column_conditions'
+require_relative 'ordering'
+require_relative 'scope_procedure'
+require_relative 'searchable'
+
+module ModernSearchlogic
+  module ActiveRecordMethods
+    def self.install
+      ActiveRecord::Base.__send__(:include, self)
+      ActiveRecord::Relation.__send__(:include, Ordering)
+    end
+
+    def self.included(base)
+      base.include DefaultScoping
+      base.include ScopeTracking
+      base.include ColumnConditions
+      base.include ScopeProcedure
+      base.include Searchable
+    end
+  end
+end

data/lib/modern_searchlogic/column_conditions.rb

@@ -0,0 +1,303 @@
+module ModernSearchlogic
+  module ColumnConditions
+    module ClassMethods
+      def respond_to_missing?(method, *)
+        super || valid_searchlogic_scope?(method)
+      end
+
+      def valid_searchlogic_scope?(method)
+        return false if connection.tables.empty? || method =~ /^define_method_/ || abstract_class?
+
+        searchlogic_scope_dynamically_defined?(method) ||
+          !!searchlogic_column_condition_method_block(method.to_s) ||
+          _defined_scopes.include?(method.to_sym)
+      end
+
+      def dynamically_define_searchlogic_method(method)
+        return true if searchlogic_scope_dynamically_defined?(method)
+        return false unless searchlogic_scope = searchlogic_column_condition_method_block(method.to_s)
+        singleton_class.__send__(:define_method, method, &searchlogic_scope[:block])
+        self._dynamically_defined_searchlogic_scopes = self._dynamically_defined_searchlogic_scopes.merge(method => searchlogic_scope)
+        true
+      end
+
+      def searchlogic_method_arity(method)
+        method = method.to_sym
+        raise ArgumentError, "Not a searchlogic scope" unless valid_searchlogic_scope?(method)
+        dynamically_define_searchlogic_method(method)
+
+        searchlogic_scope_dynamically_defined?(method) ?
+          _dynamically_defined_searchlogic_scopes[method][:arity] :
+          self.method(method).arity
+      end
+
+      private
+
+      def searchlogic_scope_dynamically_defined?(method)
+        _dynamically_defined_searchlogic_scopes.key?(method)
+      end
+
+      def searchlogic_suffix_condition(suffix, options = {}, &method_block)
+        searchlogic_suffix_conditions[suffix] = [options, method_block]
+      end
+
+      def searchlogic_prefix_condition(prefix, &method_block)
+        searchlogic_prefix_conditions[prefix] = method_block
+      end
+
+      def searchlogic_extract_arel_compatible_value(value)
+        if value.respond_to?(:map) && !value.acts_like?(:string)
+          value.map { |v| searchlogic_extract_arel_compatible_value(v) }
+        elsif value.is_a?(ActiveRecord::Base)
+          value.id
+        else
+          value
+        end
+      end
+
+      def searchlogic_arel_alias(searchlogic_suffix, arel_method, options = {})
+        value_mapper = options.fetch(:map_value, -> (x) { searchlogic_extract_arel_compatible_value(x) })
+
+        searchlogic_suffix_condition "_#{searchlogic_suffix}", options do |column_name, *args|
+          values = coerce_and_validate_args_for_arel_aliases!(args, options)
+          arel_table[column_name].__send__(arel_method, value_mapper.call(values))
+        end
+
+        searchlogic_suffix_condition "_#{searchlogic_suffix}_any", options do |column_name, *args|
+          values = coerce_and_validate_args_for_arel_aliases!(args, options.merge(:any_or_all => true))
+          arel_table[column_name].__send__("#{arel_method}_any", values.map(&value_mapper))
+        end
+
+        searchlogic_suffix_condition "_#{searchlogic_suffix}_all", options do |column_name, *args|
+          values = coerce_and_validate_args_for_arel_aliases!(args, options.merge(:any_or_all => true))
+          arel_table[column_name].__send__("#{arel_method}_all", values.map(&value_mapper))
+        end
+      end
+
+      def searchlogic_active_record_alias(searchlogic_suffix, options = {}, &block)
+        searchlogic_suffix_condition "_#{searchlogic_suffix}" do |column_name, *args|
+          raise ArgumentError, "wrong number of arguments (0 for >= 1)" if args.empty?
+          raise ArgumentError, "unsupported searchlogic suffix #{searchlogic_suffix} passed" unless [:in, :not_in].include?(searchlogic_suffix)
+
+          relation = unscoped { instance_exec(column_name, args, &block) }
+          if ActiveRecord::VERSION::MAJOR >= 5
+            relation.where_clause&.ast
+          elsif [3, 4].include?(ActiveRecord::VERSION::MAJOR)
+            relation.where_values.reduce(&:and)
+          end
+        end
+      end
+
+      def searchlogic_suffix_condition_match(method_name)
+        suffix_regexp = searchlogic_suffix_conditions.keys.join('|')
+        if match = method_name.match(/\A(#{column_names_regexp}(?:_or_#{column_names_regexp})*)(#{suffix_regexp})\z/)
+          options, method_block = searchlogic_suffix_conditions.fetch(match[2])
+          column_names = match[1].split('_or_')
+
+          arity = calculate_arity(method_block)
+
+          {
+            arity: arity,
+            block: lambda do |*args|
+              validate_argument_count!(arity, args.length) if arity >= 0
+              arel_nodes = column_names.map do |n|
+                instance_exec(n, *args, &method_block)
+              end
+              where(arel_nodes.reduce(:or))
+            end
+          }
+        end
+      end
+
+      def searchlogic_prefix_match(method_name)
+        prefix_regexp = searchlogic_prefix_conditions.keys.join('|')
+        if match = method_name.match(/\A(#{prefix_regexp})(#{column_names_regexp})\z/)
+          method_block = searchlogic_prefix_conditions.fetch(match[1])
+
+          arity = calculate_arity(method_block)
+
+          {
+            arity: arity,
+            block: lambda do |*args|
+              validate_argument_count!(method_block.arity - 1, args.length) if method_block.arity >= 1
+              instance_exec(match[2], *args, &method_block)
+            end
+          }
+        elsif match = method_name.match(/\A(#{prefix_regexp})(#{association_names_regexp})_(\S+)\z/)
+          prefix, association_name, rest = match.to_a.drop(1)
+
+          searchlogic_association_finder_method(association_by_name.fetch(association_name.to_sym), prefix + rest)
+        end
+      end
+
+      def searchlogic_association_suffix_match(method_name)
+        if match = method_name.match(/\A(#{association_names_regexp})_(\S+)\z/)
+          searchlogic_association_finder_method(association_by_name.fetch(match[1].to_sym), match[2])
+        end
+      end
+
+      def searchlogic_column_boolean_match(method_name)
+        if match = method_name.match(/^not_(.*)/)
+          column_name = match[1]
+          if boolean_column?(column_name)
+            {arity: 0, block: lambda { where(column_name => false) }}
+          end
+        elsif boolean_column?(method_name)
+          {arity: 0, block: lambda { where(method_name => true)}}
+        end
+      end
+
+      def boolean_column?(name)
+        column = columns_hash[name.to_s]
+        column && column.type == :boolean
+      end
+
+      def searchlogic_association_finder_method(association, method_name)
+        method_name = method_name.to_sym
+        if !association.options[:polymorphic] && association.klass.valid_searchlogic_scope?(method_name)
+          arity = association.klass.searchlogic_method_arity(method_name)
+
+          {
+            arity: arity,
+            block: lambda do |*args|
+              joins(association.name).merge(association.klass.__send__(method_name, *args))
+            end
+          }
+        end
+      end
+
+      def association_by_name
+        reflect_on_all_associations.each.with_object({}) do |assoc, obj|
+          obj[assoc.name] = assoc
+        end
+      end
+
+      def association_names_regexp
+        association_by_name.keys.join('|')
+      end
+
+      def searchlogic_column_condition_method_block(method)
+        return if self == ActiveRecord::Base
+
+        method = method.to_s
+        searchlogic_prefix_match(method) ||
+          searchlogic_suffix_condition_match(method) ||
+          searchlogic_association_suffix_match(method) ||
+          searchlogic_column_boolean_match(method)
+      end
+
+      def column_names_regexp
+        "(?:#{column_names.join('|')})"
+      end
+
+      def method_missing(method, *args, &block)
+        return super if connection.tables.empty? || abstract_class?
+        return super unless dynamically_define_searchlogic_method(method)
+
+        __send__(method, *args, &block)
+      end
+
+      def coerce_and_validate_args_for_arel_aliases!(args, options)
+        any_or_all = options[:any_or_all]
+
+        if options[:takes_array_args]
+          args = [any_or_all ? args : args.flatten]
+        elsif any_or_all
+          args = [args.flatten]
+        end
+
+        if any_or_all
+          raise ArgumentError, "wrong number of arguments (0 for >= 1)" if args.first.length.zero?
+        elsif args.length != 1
+          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)"
+        end
+
+        args.first
+      end
+
+      def validate_argument_count!(expected_args, actual_args)
+        if expected_args != actual_args
+          raise ArgumentError, "wrong number of arguments (#{actual_args} for #{expected_args})"
+        end
+      end
+
+      def calculate_arity(block)
+        block.arity > 0 ? block.arity - 1 : block.arity + 1
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+
+      base.class_eval do
+        class_attribute :searchlogic_suffix_conditions
+        self.searchlogic_suffix_conditions = {}
+
+        class_attribute :searchlogic_prefix_conditions
+        self.searchlogic_prefix_conditions = {}
+
+        searchlogic_arel_alias :equals, :eq
+        searchlogic_arel_alias :eq, :eq
+        searchlogic_arel_alias :is, :eq
+        searchlogic_arel_alias :does_not_equal, :not_eq
+        searchlogic_arel_alias :ne, :not_eq
+        searchlogic_arel_alias :not_eq, :not_eq
+        searchlogic_arel_alias :not, :not_eq
+        searchlogic_arel_alias :is_not, :not_eq
+        searchlogic_arel_alias :greater_than, :gt
+        searchlogic_arel_alias :gt, :gt
+        searchlogic_arel_alias :less_than, :lt
+        searchlogic_arel_alias :lt, :lt
+        searchlogic_arel_alias :greater_than_or_equal_to, :gteq
+        searchlogic_arel_alias :gte, :gteq
+        searchlogic_arel_alias :less_than_or_equal_to, :lteq
+        searchlogic_arel_alias :lte, :lteq
+        searchlogic_active_record_alias :in do |column, values|
+          has_nil = values.include?(nil)
+          values = values.flatten.compact
+          subs = [values]
+          if has_nil
+            subs << nil
+          end
+          where(column => searchlogic_extract_arel_compatible_value(subs))
+        end
+        searchlogic_active_record_alias :not_in do |column, values|
+          values = searchlogic_extract_arel_compatible_value(values.flatten)
+          query = values.map { "#{connection.quote_table_name(arel_table.name)}.#{connection.quote_column_name(column)} != ?" }.join(" AND ")
+          where(query, *values)
+        end
+
+        searchlogic_arel_alias :like, :matches, :map_value => -> (val) { "%#{val}%" }
+        searchlogic_arel_alias :begins_with, :matches, :map_value => -> (val) { "#{val}%" }
+        searchlogic_arel_alias :ends_with, :matches, :map_value => -> (val) { "%#{val}" }
+        searchlogic_arel_alias :not_like, :does_not_match, :map_value => -> (val) { "%#{val}%" }
+        searchlogic_arel_alias :not_begin_with, :does_not_match, :map_value => -> (val) { "#{val}%" }
+        searchlogic_arel_alias :not_end_with, :does_not_match, :map_value => -> (val) { "%#{val}" }
+
+        searchlogic_suffix_condition '_blank' do |column_name|
+          arel_table[column_name].eq(nil).or(arel_table[column_name].eq(''))
+        end
+
+        searchlogic_suffix_condition '_present' do |column_name|
+          arel_table[column_name].not_eq(nil).and(arel_table[column_name].not_eq(''))
+        end
+
+        null_matcher = lambda { |column_name| arel_table[column_name].eq(nil) }
+        searchlogic_suffix_condition '_null', &null_matcher
+        searchlogic_suffix_condition '_nil', &null_matcher
+
+        not_null_matcher = lambda { |column_name| arel_table[column_name].not_eq(nil) }
+        searchlogic_suffix_condition '_not_null', &not_null_matcher
+        searchlogic_suffix_condition '_not_nil', &not_null_matcher
+
+        searchlogic_prefix_condition 'descend_by_' do |column_name|
+          order(arel_table[column_name].desc)
+        end
+
+        searchlogic_prefix_condition 'ascend_by_' do |column_name|
+          order(arel_table[column_name].asc)
+        end
+      end
+    end
+  end
+end

data/lib/modern_searchlogic/default_scoping.rb

@@ -0,0 +1,13 @@
+module ModernSearchlogic
+  module DefaultScoping
+    module ClassMethods
+      def searchlogic_default_scope
+        respond_to?(:scoped) ? scoped : all
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/modern_searchlogic/ordering.rb

@@ -0,0 +1,20 @@
+module ModernSearchlogic
+  module Ordering
+    def self.included(base)
+      base.module_eval do
+        define_method(:order_with_modern_searchlogic) do |*args|
+          args.reduce(self) do |scope, arg|
+            expression = arg.to_s
+            if expression.match(/^(ascend|descend)_by_(.*)/) && respond_to?(expression)
+              scope.send(expression)
+            else
+              scope.order_without_modern_searchlogic(arg)
+            end
+          end
+        end
+        alias_method :order_without_modern_searchlogic, :order
+        alias_method :order, :order_with_modern_searchlogic
+      end
+    end
+  end
+end

data/lib/modern_searchlogic/railtie.rb

@@ -0,0 +1,9 @@
+module ModernSearchlogic
+  class Railtie < Rails::Railtie
+    initializer 'modern_searchlogic.setup_activerecord' do
+      ActiveSupport.on_load(:active_record) do
+        ModernSearchlogic::ActiveRecordMethods.install
+      end
+    end
+  end
+end

data/lib/modern_searchlogic/scope_procedure.rb

@@ -0,0 +1,18 @@
+module ModernSearchlogic
+  module ScopeProcedure
+    def self.included(base)
+      base.singleton_class.class_eval do
+        def scope_procedure(name, options = nil)
+          if options.is_a?(Proc)
+            define_singleton_method(name, &options)
+          else
+            define_singleton_method(name) do |*args|
+              public_send(options, *args)
+            end
+          end
+          self._defined_scopes << name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/modern_searchlogic/scope_tracking.rb

@@ -0,0 +1,21 @@
+module ModernSearchlogic
+  module ScopeTracking
+    module ClassMethods
+      def scope(name, body, &block)
+        super(name, body, &block).tap do |*|
+          self._defined_scopes |= [name.to_sym]
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        class_attribute :_defined_scopes
+        self._defined_scopes = Set.new
+        class_attribute :_dynamically_defined_searchlogic_scopes
+        self._dynamically_defined_searchlogic_scopes = {}
+      end
+    end
+  end
+end

data/lib/modern_searchlogic/search.rb

@@ -0,0 +1,90 @@
+module ModernSearchlogic
+  class Search
+    def self.search(model_class, options = {})
+      new(model_class).tap do |s|
+        options.each do |k, v|
+          k = k.to_sym
+          s.apply_search(k, v)
+        end
+      end
+    end
+
+    def initialize(model_class, options = {})
+      @model_class, @options = model_class, options
+    end
+
+    def respond_to_missing?(method, *)
+      super ||
+        searchlogic_default_scope.respond_to?(method) ||
+        search_scope_method?(method)
+    end
+
+    def apply_search(scope_name, value)
+      options.merge!(scope_name.to_sym => value)
+    end
+
+    def get_search_value(scope_name)
+      options[scope_name]
+    end
+
+    def order=(new_order)
+      options[:order] = new_order
+    end
+
+    def order
+      options[:order]
+    end
+
+    private
+
+    attr_reader :model_class, :options
+    delegate :searchlogic_default_scope, :valid_searchlogic_scope?, :to => :model_class
+
+    def materialize_scope
+      scope = searchlogic_default_scope
+
+      options.each do |k, v|
+        if k.to_s == 'order'
+          if model_class.valid_searchlogic_scope?(v) && model_class.searchlogic_method_arity(v).zero?
+            scope = scope.__send__(v)
+          end
+        elsif model_class.valid_searchlogic_scope?(k)
+          if model_class.searchlogic_method_arity(k).zero?
+            unless v.to_s == 'false'
+              scope = scope.__send__(k)
+            end
+          else
+            scope = scope.__send__(k, *Array.wrap([v]))
+          end
+        else
+          scope = scope.where(k => v)
+        end
+      end
+
+      scope
+    end
+
+    def search_scope_method?(method)
+      method.to_s =~ /\A(\S+?)(=)?\z/ && valid_searchlogic_scope?($1)
+    end
+
+    def method_missing(method, *args, &block)
+      if search_scope_method?(method)
+        applied_args = args.many? ? args : args.first
+        if method.to_s.ends_with?('=')
+          apply_search(method.to_s.chomp('='), applied_args)
+        else
+          if args.present? || model_class.searchlogic_method_arity(method).zero?
+            self.class.new(model_class, options.merge(method => args.present? ? applied_args : true))
+          else
+            get_search_value(method)
+          end
+        end
+      elsif searchlogic_default_scope.respond_to?(method)
+        materialize_scope.__send__(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/modern_searchlogic/searchable.rb

@@ -0,0 +1,15 @@
+require_relative 'search'
+
+module ModernSearchlogic
+  module Searchable
+    module ClassMethods
+      def search(options = {})
+        Search.search(self, options)
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

data/lib/modern_searchlogic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ModernSearchlogic
+  VERSION = "1.0.1"
+end

data/lib/modern_searchlogic.rb

@@ -0,0 +1,5 @@
+require 'modern_searchlogic/active_record_methods'
+require 'modern_searchlogic/railtie'
+
+module ModernSearchlogic
+end

data/lib/tasks/modern_searchlogic_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :modern_searchlogic do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: modern_searchlogic
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Andrew Warner
+- Reece Dunham
+- Genius Tech Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.14
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Because it's rampant through your codebase, and you can't upgrade to
+  Rails 3 otherwise.
+email:
+- wwarner.andrew@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/modern_searchlogic.rb
+- lib/modern_searchlogic/active_record_methods.rb
+- lib/modern_searchlogic/column_conditions.rb
+- lib/modern_searchlogic/default_scoping.rb
+- lib/modern_searchlogic/ordering.rb
+- lib/modern_searchlogic/railtie.rb
+- lib/modern_searchlogic/scope_procedure.rb
+- lib/modern_searchlogic/scope_tracking.rb
+- lib/modern_searchlogic/search.rb
+- lib/modern_searchlogic/searchable.rb
+- lib/modern_searchlogic/version.rb
+- lib/tasks/modern_searchlogic_tasks.rake
+homepage: https://github.com/RDIL/modern_searchlogic
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Searchlogic, but for AREL (Rails 3+).
+test_files: []