action_scope 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 43bbde8d9aa5ef6333ba5c917da1e09527174e56ed97e21f7ca3672088ed311b
+  data.tar.gz: e1935b3f2c97f025e2578a4cc0125acd9239bb181ac1158fd0d282f6fc89d63a
+SHA512:
+  metadata.gz: fe694f26484fb9e44c6033c5b87e5760b7ec409d54223d5304bc17739351256e2dce06d5b43d1122e6b465eb06283229f44cf22afe40d23f5e8c71122af8e910
+  data.tar.gz: e04c2a45d939089277dc57a2f53efff52a58dadfb83958e76ef48f3296bea1c9850c4db64739b1ad0dd0168f554ed6b7d6891569ce8b094cf98678b189673aaf

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-09-11
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 OrestF
+
+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,348 @@
+# ActionScope
+
+ActionScope provides a comprehensive set of dynamic scopes for ActiveRecord models, including basic column filtering, text matching, range queries, association scopes, multi-column search, and sorting capabilities. Automatically generates scopes based on model attributes and associations.
+
+## Features
+
+- **Basic Scopes**: Automatic `by_column_name` scopes for all model attributes
+- **Text Matching**: Fuzzy search scopes for string/text columns
+- **Range Queries**: Greater than, less than, and between scopes for numeric/date columns
+- **Association Scopes**: Automatic scopes for model associations
+- **Multi-Column Search**: Search across multiple columns with a single query
+- **Sorting**: Dynamic sorting scopes for all columns
+- **Type-Aware**: Automatically detects column types and generates appropriate scopes
+- **Rails 7+ Compatible**: Works with modern Rails versions
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'action_scope'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install action_scope
+```
+
+## Usage
+
+### Basic Setup
+
+Include ActionScope in your ActiveRecord models and call `action_scope`:
+
+```ruby
+class User < ApplicationRecord
+  include ActionScope
+  
+  action_scope
+  
+  # Your model code here...
+end
+```
+
+### Example Model
+
+Let's say you have a User model with the following structure:
+
+```ruby
+# db/migrate/xxx_create_users.rb
+class CreateUsers < ActiveRecord::Migration[7.0]
+  def change
+    create_table :users do |t|
+      t.string :name
+      t.string :email
+      t.text :bio
+      t.integer :age
+      t.decimal :salary, precision: 10, scale: 2
+      t.datetime :last_login_at
+      t.date :birth_date
+      t.boolean :active
+      t.references :company, null: false, foreign_key: true
+      
+      t.timestamps
+    end
+  end
+end
+
+# app/models/user.rb
+class User < ApplicationRecord
+  include ActionScope
+  
+  belongs_to :company
+  has_many :posts
+  
+  action_scope
+end
+
+# app/models/company.rb
+class Company < ApplicationRecord
+  include ActionScope
+  
+  has_many :users
+  
+  action_scope
+end
+```
+
+### Generated Scopes
+
+ActionScope automatically generates the following types of scopes:
+
+#### 1. Basic Scopes (`by_column_name`)
+
+For every column in your model:
+
+```ruby
+# Filter by exact values
+User.by_name("John Doe")
+User.by_email("john@example.com")
+User.by_age(30)
+User.by_active(true)
+
+# Chain multiple filters
+User.by_name("John").by_active(true).by_age(30)
+```
+
+#### 2. Text Matching Scopes (`by_column_name_match`)
+
+For string and text columns:
+
+```ruby
+# Fuzzy search (uses LIKE %query%)
+User.by_name_match("john")      # Finds "John Doe", "Johnny", etc.
+User.by_email_match("gmail")    # Finds emails containing "gmail"
+User.by_bio_match("developer")  # Searches bio text
+```
+
+#### 3. Range Scopes
+
+For numeric, date, and datetime columns:
+
+```ruby
+# Greater than / Less than
+User.by_age_gt(25)              # age > 25
+User.by_age_gte(25)             # age >= 25
+User.by_age_lt(65)              # age < 65
+User.by_age_lte(65)             # age <= 65
+
+# Date ranges
+User.by_birth_date_gte(Date.new(1990, 1, 1))
+User.by_last_login_at_lt(1.week.ago)
+
+# Salary ranges
+User.by_salary_gte(50000)
+User.by_salary_lte(100000)
+
+# Chain range conditions
+User.by_age_gte(25).by_age_lte(65)  # Between 25 and 65
+```
+
+#### 4. Association Scopes
+
+For belongs_to and has_many associations:
+
+```ruby
+# Filter by association ID
+User.by_company(1)              # Users belonging to company with ID 1
+User.by_company(company)        # Users belonging to company object
+
+# Works with company model too
+Company.by_user(user)           # Companies associated with user
+```
+
+#### 5. Multi-Column Search
+
+Search across multiple columns simultaneously:
+
+```ruby
+# Searches name, email, bio, and id columns
+User.by_search_query("john")
+
+# Finds users where any searchable column contains "john"
+User.by_search_query("developer")  # Matches name, email, or bio
+```
+
+#### 6. Sorting Scopes
+
+For all columns:
+
+```ruby
+# Sort ascending (default)
+User.sort_by_name
+User.sort_by_age
+User.sort_by_created_at
+
+# Sort descending
+User.sort_by_name('desc')
+User.sort_by_salary('desc')
+
+# Generic sorting method
+User.sorted_by(:name, 'asc')
+User.sorted_by(:age, 'desc')
+```
+
+### Advanced Usage
+
+#### Selective Scope Generation
+
+Generate scopes only for specific columns:
+
+```ruby
+class User < ApplicationRecord
+  include ActionScope
+  
+  # Only generate scopes for name and email
+  action_scope :name, :email
+end
+```
+
+#### Excluding Columns
+
+Exclude certain columns from scope generation:
+
+```ruby
+class User < ApplicationRecord
+  include ActionScope
+  
+  # Generate scopes for all columns except password_digest
+  action_scope except: [:password_digest, :secret_token]
+end
+```
+
+#### Custom Configuration
+
+You can also provide a block for custom configuration:
+
+```ruby
+class User < ApplicationRecord
+  include ActionScope
+  
+  action_scope do |model|
+    # Custom logic here
+    puts "Generating scopes for #{model.name}"
+  end
+end
+```
+
+### Real-World Examples
+
+#### Building Complex Queries
+
+```ruby
+# Find active adult users from a specific company with recent activity
+User.by_active(true)
+    .by_age_gte(18)
+    .by_company(company)
+    .by_last_login_at_gte(1.month.ago)
+    .sort_by_name
+
+# Search for users and sort by salary
+User.by_search_query("engineer")
+    .by_salary_gte(70000)
+    .sort_by_salary('desc')
+
+# Filter by date ranges
+User.by_birth_date_gte(Date.new(1980, 1, 1))
+    .by_birth_date_lte(Date.new(2000, 12, 31))
+    .by_active(true)
+```
+
+### Scope Introspection
+
+ActionScope provides methods to inspect generated scopes:
+
+#### `action_scope_options` - Complete Scope Overview
+
+The `action_scope_options` method (aliased as `options_for_search`) returns a comprehensive hash of all available scopes with their types and options:
+
+```ruby
+User.action_scope_options
+# Returns a hash like this:
+
+{
+  # Basic scopes with column types
+  :by_name => nil,
+  :by_email => nil, 
+  :by_bio => nil,
+  :by_age => nil,
+  :by_salary => nil,
+  :by_last_login_at => nil,
+  :by_birth_date => nil,
+  :by_active => nil,
+  :by_company_id => nil,
+  
+  # Text matching scopes for string/text columns
+  :by_name_match => nil,
+  :by_email_match => nil,
+  :by_bio_match => nil,
+  
+  # Multi-column search with searchable columns
+  :by_search_query => [
+    "id", "name", "email", "bio", "age", "salary", 
+    "last_login_at", "birth_date", "active", "company_id"
+  ],
+  
+  # Range scopes for numeric/date columns
+  :by_age_gte => :integer,
+  :by_age_lte => :integer, 
+  :by_age_gt => :integer,
+  :by_age_lt => :integer,
+  :by_salary_gte => :decimal,
+  :by_salary_lte => :decimal,
+  :by_salary_gt => :decimal,
+  :by_salary_lt => :decimal,
+  :by_last_login_at_gte => :datetime,
+  :by_last_login_at_lte => :datetime,
+  :by_last_login_at_gt => :datetime,
+  :by_last_login_at_lt => :datetime,
+  :by_birth_date_gte => :date,
+  :by_birth_date_lte => :date,
+  :by_birth_date_gt => :date,
+  :by_birth_date_lt => :date,
+  
+  # Association scopes
+  :by_company => "id",
+  
+  # Sorting scopes
+  :sort_by_name => ["asc", "desc"],
+  :sort_by_email => ["asc", "desc"],
+  :sort_by_age => ["asc", "desc"],
+  :sort_by_salary => ["asc", "desc"],
+  :sort_by_created_at => ["asc", "desc"]
+}
+```
+
+#### Individual Introspection Methods
+
+You can also access specific scope types individually:
+
+```ruby
+# Basic scopes with their column types
+User.basic_scopes_with_types
+
+# Text matching scopes  
+User.matchable_scopes_with_types
+
+# Range scopes with their column types
+User.rangeable_scopes_scopes_with_types
+
+# Sorting scopes with available directions
+User.sortable_scopes_with_directions
+
+# Association scopes with their primary keys
+User.association_scopes_with_primary_keys
+
+# Multi-search scope with searchable column names
+User.multi_searchable_scopes_with_column_names
+```
+
+This introspection is particularly useful for building dynamic UIs, API documentation, or debugging scope availability.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/action_scope/associations.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActionScope::Associations
+  extend ActiveSupport::Concern if defined?(ActiveSupport::Concern)
+
+  EXCLUDED_ASSOCIATION_SCOPES_CLASSES = %w[ActiveStorage::Attachment ActiveStorage::Blob].freeze
+
+  class_methods do
+    def load_association_scopes
+      yield(self) if block_given?
+
+      action_scope_association_scopes
+    end
+
+    def action_scope_association_scopes(*association_names, except: [])
+      return unless db_ready?
+
+      association_names = association_names.presence || relation_names_for_association_scopes
+      assoc_to_define = associations_for_scopes.select do |afs|
+        afs.name.in?(association_names.map(&:to_sym)) && !afs.name.in?(except.map(&:to_sym))
+      end
+      assoc_to_define.each do |association|
+        scope "by_#{association.name.to_s.singularize}", lambda { |value|
+          fltrs = [{ association.name.to_s => { association.association_primary_key => { 'is' => value } } }]
+          ActiveRecord::PredicateBuilder.filter_joins(klass, fltrs).flatten.reduce(self) do |_acc, j|
+            if j.is_a?(String) || j.is_a?(Arel::Nodes::Join)
+              joins(j)
+            elsif j.present?
+              left_outer_joins(j)
+            else
+              self
+            end
+          end.where(association.name.to_s => { association.association_primary_key => value })
+        }
+      end
+    end
+
+    def relation_names_for_association_scopes
+      associations_for_scopes.map(&:name)
+    end
+
+    def associations_for_scopes
+      return [] unless table_exists?
+
+      reflect_on_all_associations.reject { |a| a.polymorphic? || a.class_name.in?(EXCLUDED_ASSOCIATION_SCOPES_CLASSES) }
+    end
+
+    def association_scopes_with_primary_keys
+      associations_for_scopes.each_with_object({}) do |association, h|
+        if defined_scopes.include?(:"by_#{association.name.to_s.singularize}")
+          h[:"by_#{association.name.to_s.singularize}"] = association.association_primary_key
+        end
+      end
+    end
+  end
+end

data/lib/action_scope/basic.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActionScope::Basic
+  extend ActiveSupport::Concern if defined?(ActiveSupport::Concern)
+
+  BASIC_SCOPES_COLUMN_TYPES = %i[string text integer float decimal datetime date time].freeze
+
+  class_methods do
+    def action_scope_basic_scopes(*col_names, except: [])
+      return unless db_ready?
+
+      col_names = col_names.presence || column_names_for_basic_scopes
+      col_names -= Array.wrap(except).map(&:to_s)
+      Array.wrap(col_names).each do |column_name|
+        scope "by_#{column_name}", ->(value) { where(column_name => value) }
+      end
+    end
+
+    def columns_types_basic_scopes
+      return {} unless db_ready?
+
+      columns_hash.transform_values(&:type).select do |column, type|
+        BASIC_SCOPES_COLUMN_TYPES.include?(type) && !reflect_on_all_associations.map(&:foreign_key).include?(column)
+      end
+    end
+
+    def column_names_for_basic_scopes = columns_types_basic_scopes.keys
+
+    def basic_scopes_with_types
+      column_names_for_basic_scopes.each_with_object({}) do |(column, type), h|
+        defined = defined_scopes.include?(:"by_#{column}")
+        h[:"by_#{column}"] = type if defined
+        h[:"by_#{column}"] = defined_enums[column.to_s].keys if defined && defined_enums.keys.include?(column.to_s)
+      end
+    end
+  end
+end

data/lib/action_scope/matchable.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActionScope::Matchable
+  extend ActiveSupport::Concern if defined?(ActiveSupport::Concern)
+
+  MATCHABLE_COLUMN_TYPES = %i[string text].freeze
+
+  included do
+    scope :match, ->(column_name, query) { where(arel_table[column_name].matches("%#{query}%")) }
+  end
+
+  class_methods do
+    def action_scope_matchable_scopes(*col_names, except: [])
+      return unless db_ready?
+
+      col_names = col_names.presence || column_names_for_matchable_scopes
+      col_names -= Array.wrap(except).map(&:to_s)
+      Array.wrap(col_names).each do |column_name|
+        scope "by_#{column_name}_match", ->(query) { match(column_name, query) }
+      end
+    end
+
+    def columns_types_for_matchable_scopes
+      return {} unless db_ready?
+
+      columns_hash.transform_values(&:type).select do |column, type|
+        MATCHABLE_COLUMN_TYPES.include?(type) && !reflect_on_all_associations.map(&:foreign_key).include?(column)
+      end
+    end
+
+    def column_names_for_matchable_scopes = columns_types_for_matchable_scopes.keys
+
+    def matchable_scopes_with_types
+      column_names_for_matchable_scopes.each_with_object({}) do |(column, type), h|
+        h[:"by_#{column}_match"] = type if defined_scopes.include?(:"by_#{column}_match")
+      end
+    end
+  end
+end

data/lib/action_scope/multi_searchable.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActionScope::MultiSearchable
+  extend ActiveSupport::Concern if defined?(ActiveSupport::Concern)
+
+  SEARCHABLE_STRING_COLUMN_TYPES = %i[text string citext].freeze
+  SEARCHABLE_NUMBER_COLUMN_TYPES = %i[integer float].freeze
+  SEARCHABLE_COLUMN_TYPES = SEARCHABLE_STRING_COLUMN_TYPES + SEARCHABLE_NUMBER_COLUMN_TYPES
+
+  class_methods do
+    def action_scope_multi_searchable_scope(*col_names, except: [])
+      return unless db_ready?
+
+      col_names = col_names.presence || define_multi_searchable_columns
+      col_names -= Array.wrap(except).map(&:to_s)
+      invalid_column = Array.wrap(col_names).map(&:to_s) - column_names
+      raise ArgumentError, "Invalid column names: #{invalid_column.join(',')}" if invalid_column.present?
+
+      define_singleton_method(:column_names_for_multi_search_query) { col_names }
+
+      scope :by_search_query, lambda { |keyword|
+        where(or_join(build_multicolumn_search_filters(klass, col_names, keyword)))
+      }
+    end
+    alias_method :action_scope_multi_searchable_scopes, :action_scope_multi_searchable_scope
+
+    def define_multi_searchable_columns
+      return [] unless table_exists?
+
+      (columns.map { |c| c.type.in?(SEARCHABLE_COLUMN_TYPES) ? c.name : nil }.compact << primary_key).uniq
+    end
+
+    def column_names
+      return [] unless table_exists?
+
+      super
+    end
+
+    def column_names_for_multi_search_query
+      define_multi_searchable_columns
+    end
+
+    def multi_searchable_scopes_with_column_names
+      { by_search_query: column_names_for_multi_search_query }
+    end
+
+    def build_multicolumn_search_filters(model, column_names, keyword)
+      arel_table = model.arel_table
+
+      column_names = (Array.wrap(column_names).map(&:to_s) << model.primary_key) & model.column_names
+
+      column_names.map do |name|
+        column_type = model.columns_hash[name.to_s]&.type
+
+        next unless column_type
+
+        if SEARCHABLE_STRING_COLUMN_TYPES.include?(column_type)
+          arel_table[name].matches("%#{keyword}%")
+        elsif SEARCHABLE_NUMBER_COLUMN_TYPES.include?(column_type)
+          arel_table[name].eq(keyword.to_f) if keyword.to_s.match?(/\A\d/)
+        else
+          arel_table[name].eq(keyword)
+        end
+      end.compact
+    end
+
+    def or_join(filter_array)
+      filter_array.reduce(nil) do |acc, filter|
+        next acc = filter unless acc
+
+        acc.or(filter)
+      end
+    end
+  end
+end

data/lib/action_scope/rangeable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActionScope::Rangeable
+  extend ActiveSupport::Concern if defined?(ActiveSupport::Concern)
+
+  RANGEABLE_COLUMN_TYPES = %i[integer float decimal datetime date time].freeze
+
+  included do
+    scope :gt, ->(column, value) { where(arel_table[column].gt(value)) }
+    scope :lt, ->(column, value) { where(arel_table[column].lt(value)) }
+    scope :gte, ->(column, value) { where(arel_table[column].gteq(value)) }
+    scope :lte, ->(column, value) { where(arel_table[column].lteq(value)) }
+  end
+
+  class_methods do
+    def action_scope_rangeable_scopes(*col_names, except: [])
+      return unless db_ready?
+
+      col_names = col_names.presence || column_names_for_rangeable_scopes
+      col_names -= Array.wrap(except).map(&:to_s)
+      col_names.each do |column_name|
+        scope "by_#{column_name}_gte", ->(value) { gte(column_name, value) }
+        scope "by_#{column_name}_lte", ->(value) { lte(column_name, value) }
+        scope "by_#{column_name}_gt", ->(value) { gt(column_name, value) }
+        scope "by_#{column_name}_lt", ->(value) { lt(column_name, value) }
+      end
+    end
+
+    def column_names_for_rangeable_scopes = columns_types_for_rangeable_scopes.keys
+
+    def columns_types_for_rangeable_scopes
+      return {} unless db_ready?
+
+      columns_hash.transform_values(&:type).select do |column, type|
+        RANGEABLE_COLUMN_TYPES.include?(type) && !reflect_on_all_associations.map(&:foreign_key).include?(column)
+      end
+    end
+
+    def rangeable_scopes_scopes_with_types
+      columns_types_for_rangeable_scopes.each_with_object({}) do |(column, type), h|
+        h[:"by_#{column}_gte"] = type if defined_scopes.include?(:"by_#{column}_gte")
+        h[:"by_#{column}_lte"] = type if defined_scopes.include?(:"by_#{column}_lte")
+        h[:"by_#{column}_gt"] = type if defined_scopes.include?(:"by_#{column}_gt")
+        h[:"by_#{column}_lt"] = type if defined_scopes.include?(:"by_#{column}_lt")
+      end
+    end
+  end
+end

data/lib/action_scope/scopable.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActionScope::Scopable
+  # extend ActiveSupport::Concern
+  #
+  # include ActionScope::Associations
+  # include ActionScope::Basic
+  # include ActionScope::Matchable
+  # include ActionScope::MultiSearchable
+  # include ActionScope::Rangeable
+  # include ActionScope::Sortable
+  #
+  # class_methods do
+  #   def db_ready?
+  #     need_migration =
+  #       if Rails.version.to_f >= 7.2
+  #         ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.needs_migration?
+  #       else
+  #         ActiveRecord::Base.connection.migration_context.needs_migration?
+  #       end
+  #     ActiveRecord::Base.connection && ActiveRecord::Base.connected? && !need_migration
+  #   end
+  #
+  #   def define_action_scope_scopes(*col_names, except: [])
+  #     return unless db_ready?
+  #
+  #     yield(self) if block_given?
+  #
+  #     define_association_scopes(*col_names, except: except)
+  #     define_basic_scopes(*col_names, except: except)
+  #     define_matchable_scopes(*col_names, except: except)
+  #     define_multi_searchable_scopes(*col_names, except: except)
+  #     define_rangeable_scopes(*col_names, except: except)
+  #     define_sortable_scopes(*col_names, except: except)
+  #   end
+  #
+  #   def options_for_search
+  #     %i[
+  #       association_scopes_with_primary_keys
+  #       basic_scopes_with_types
+  #       matchable_scopes_with_types
+  #       multi_searchable_scopes_with_column_names
+  #       rangeable_scopes_scopes_with_types
+  #       sortable_scopes_with_directions
+  #     ].each_with_object({}) do |scope, options|
+  #       options.merge!(send(scope)) if defined?(scope)
+  #     end
+  #   end
+  # end
+end

data/lib/action_scope/sortable.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActionScope::Sortable
+  extend ActiveSupport::Concern if defined?(ActiveSupport::Concern)
+
+  SORTABLE_SCOPES_PREFIX = 'sort_by'
+
+  included do
+    scope :sorted_by, lambda { |col_names, direction = 'asc'|
+      order(direction.to_s.downcase == 'asc' ? arel_table[col_names].asc : arel_table[col_names].desc)
+    }
+  end
+
+  class_methods do
+    def action_scope_sortable_scopes(*col_names, except: [])
+      return unless db_ready?
+
+      col_names = column_names_for_sortable_scopes if col_names.blank?
+      col_names -= Array.wrap(except).map(&:to_s)
+      col_names.each do |col_name|
+        scope "#{SORTABLE_SCOPES_PREFIX}_#{col_name}", ->(direction = 'asc') { sorted_by(col_name, direction) }
+      end
+    end
+
+    def column_names_without_associations
+      return [] unless db_ready?
+
+      column_names - reflect_on_all_associations.map(&:foreign_key)
+    end
+
+    def column_names_for_sortable_scopes
+      column_names_without_associations
+    end
+
+    def sortable_scopes_with_directions
+      column_names_for_sortable_scopes.each_with_object({}) do |column, h|
+        h[:"#{SORTABLE_SCOPES_PREFIX}_#{column}"] = %w[asc desc] if defined_scopes.include?(:"#{SORTABLE_SCOPES_PREFIX}_#{column}")
+      end
+    end
+  end
+end

data/lib/action_scope/version.rb

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

data/lib/action_scope.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require_relative "action_scope/version"
+require_relative "action_scope/associations"
+require_relative "action_scope/basic"
+require_relative "action_scope/matchable"
+require_relative "action_scope/multi_searchable"
+require_relative "action_scope/rangeable"
+require_relative "action_scope/sortable"
+
+module ActionScope
+  class Error < StandardError; end
+
+  extend ActiveSupport::Concern if defined?(ActiveSupport::Concern)
+
+  include ActionScope::Associations
+  include ActionScope::Basic
+  include ActionScope::Matchable
+  include ActionScope::MultiSearchable
+  include ActionScope::Rangeable
+  include ActionScope::Sortable
+
+  class_methods do
+    def db_ready?
+      need_migration =
+        if Rails.version.to_f >= 7.2
+          ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.needs_migration?
+        else
+          ActiveRecord::Base.connection.migration_context.needs_migration?
+        end
+      ActiveRecord::Base.connection && ActiveRecord::Base.connected? && !need_migration
+    end
+
+    def action_scope(*col_names, except: [])
+      return unless db_ready?
+
+      yield(self) if block_given?
+
+      action_scope_association_scopes(*col_names, except: except)
+      action_scope_basic_scopes(*col_names, except: except)
+      action_scope_matchable_scopes(*col_names, except: except)
+      action_scope_multi_searchable_scopes(*col_names, except: except)
+      action_scope_rangeable_scopes(*col_names, except: except)
+      action_scope_sortable_scopes(*col_names, except: except)
+    end
+    alias action_scopes action_scope
+
+    def action_scope_options
+      %i[
+        association_scopes_with_primary_keys
+        basic_scopes_with_types
+        matchable_scopes_with_types
+        multi_searchable_scopes_with_column_names
+        rangeable_scopes_scopes_with_types
+        sortable_scopes_with_directions
+      ].each_with_object({}) do |scope, options|
+        options.merge!(send(scope)) if defined?(scope)
+      end
+    end
+    alias options_for_search action_scope_options
+  end
+end

data/sig/action_scope.rbs

@@ -0,0 +1,4 @@
+module ActionScope
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: action_scope
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- OrestF
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: ActionScope provides a comprehensive set of dynamic scopes for ActiveRecord
+  models, including basic column filtering, text matching, range queries, association
+  scopes, multi-column search, and sorting capabilities. Automatically generates scopes
+  based on model attributes and associations.
+email:
+- falchuko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/action_scope.rb
+- lib/action_scope/associations.rb
+- lib/action_scope/basic.rb
+- lib/action_scope/matchable.rb
+- lib/action_scope/multi_searchable.rb
+- lib/action_scope/rangeable.rb
+- lib/action_scope/scopable.rb
+- lib/action_scope/sortable.rb
+- lib/action_scope/version.rb
+- sig/action_scope.rbs
+homepage: https://github.com/OrestF/action_scope
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/OrestF/action_scope
+  source_code_uri: https://github.com/OrestF/action_scope
+  changelog_uri: https://github.com/OrestF/action_scope/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/OrestF/action_scope/blob/main/README.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Dynamic scoping for ActiveRecord models with automatic scope generation
+test_files: []