kiroshi 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3df16fe842c4fcd160633af8a5e4d91fa19cbb857dc135a31160c1f389a5f6c1
-  data.tar.gz: b3f98740895ae5c611d616c36472d77ce412a1086d9d6a9ffe4532a8b3fa2235
+  metadata.gz: ff66735688ded970094d5a88a9bcd67ad4f9cac7679fc55ceb75534d9b16d9fc
+  data.tar.gz: d6da2da4ec294c0d134ceff028e19b30fa5e13ddab2fae2ad0582a5fdfc559aa
 SHA512:
-  metadata.gz: 328641f23218cf3a3a3841af7027f42981dced635c03e47642e5f7bd3a9194d94e13e59a87f51f71adc51344642a682148606daff113ebf80f638e0cb0f5be19
-  data.tar.gz: e3cb7920836e0ad2d86d05875c74a57759c5b28d9309124539c61c902adaaaa3a9bf1d0f094e9b19500d23f4034563ac9de234b9fd6f36a21084054bfed09c13
+  metadata.gz: 15f142b43b0fcd7fc12f8cd2c1246031aabec104deaf1270030eca5afa56d5776d5c3fec301422c12baec0c531d5366f39832b4afe6ec3d1c83f40ce3e94aea5
+  data.tar.gz: af94b97459b7a157c6ea30f36c36b937e9a75c25b7081106cf6b6d104b3514687a7da4842e9ac847b7669954bab65f707e8a609d55e3666393f6da09cad6d9c4

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2025-08-17 15:11:59 UTC using RuboCop version 1.79.2.
+# on 2025-08-18 22:27:27 UTC using RuboCop version 1.79.2.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -13,11 +13,7 @@ RSpec/NoExpectationExample:
   Exclude:
     - 'spec/lib/kiroshi_spec.rb'
 
-# Offense count: 2
-# Configuration parameters: AllowedConstants.
-Style/Documentation:
+# Offense count: 1
+RSpec/PendingWithoutReason:
   Exclude:
-    - 'spec/**/*'
-    - 'test/**/*'
-    - 'lib/kiroshi/filter.rb'
-    - 'lib/kiroshi/filters.rb'
+    - 'spec/lib/kiroshi/filters_spec.rb'

data/README.md

@@ -7,16 +7,16 @@
 
 ## Yard Documentation
 
-[https://www.rubydoc.info/gems/kiroshi/0.1.1](https://www.rubydoc.info/gems/kiroshi/0.1.1)
+[https://www.rubydoc.info/gems/kiroshi/0.2.0](https://www.rubydoc.info/gems/kiroshi/0.2.0)
 
 Kiroshi has been designed to make filtering ActiveRecord queries easier
 by providing a flexible and reusable filtering system. It allows you to
 define filter sets that can be applied to any ActiveRecord scope,
 supporting both exact matches and partial matching using SQL LIKE operations.
 
-Current Release: [0.1.1](https://github.com/darthjee/kiroshi/tree/0.1.1)
+Current Release: [0.2.0](https://github.com/darthjee/kiroshi/tree/0.2.0)
 
-[Next release](https://github.com/darthjee/kiroshi/compare/0.1.1...master)
+[Next release](https://github.com/darthjee/kiroshi/compare/0.2.0...master)
 
 ## Installation
 
@@ -202,82 +202,8 @@ result = filters.apply(scope)
 
 The `table` parameter accepts both symbols and strings, and helps resolve column name ambiguity in complex joined queries.
 
-### Kiroshi::Filter
+## API Reference
 
-[Filter](https://www.rubydoc.info/gems/kiroshi/Kiroshi/Filter)
-is the individual filter class that applies filtering logic to ActiveRecord scopes.
-It's automatically used by `Kiroshi::Filters`, but can also be used standalone.
+Kiroshi provides a simple, clean API focused on the `Kiroshi::Filters` class. Individual filters are handled internally and don't require direct interaction in most use cases.
 
-#### Standalone Usage
-
-```ruby
-# Create individual filters
-name_filter = Kiroshi::Filter.new(:name, match: :like)
-status_filter = Kiroshi::Filter.new(:status, match: :exact)
-
-# Apply filters manually
-scope = Document.all
-scope = name_filter.apply(scope, { name: 'report' })
-scope = status_filter.apply(scope, { status: 'published' })
-```
-
-#### Filter Options
-
-- `match: :exact` - Performs exact matching (default)
-- `match: :like` - Performs partial matching using SQL LIKE
-- `table: :table_name` - Specifies which table to filter on (useful for joined queries)
-
-```ruby
-# Exact match filter
-exact_filter = Kiroshi::Filter.new(:status)
-exact_filter.apply(Document.all, { status: 'published' })
-# Generates: WHERE status = 'published'
-
-# LIKE match filter
-like_filter = Kiroshi::Filter.new(:title, match: :like)
-like_filter.apply(Document.all, { title: 'Ruby' })
-# Generates: WHERE title LIKE '%Ruby%'
-
-# Table-qualified filter for joined queries
-tag_filter = Kiroshi::Filter.new(:name, match: :like, table: :tags)
-tag_filter.apply(Document.joins(:tags), { name: 'programming' })
-# Generates: WHERE tags.name LIKE '%programming%'
-
-# Document-specific filter in joined query
-doc_filter = Kiroshi::Filter.new(:title, match: :exact, table: :documents)
-doc_filter.apply(Document.joins(:tags), { title: 'Ruby Guide' })
-# Generates: WHERE documents.title = 'Ruby Guide'
-```
-
-#### Empty Value Handling
-
-Filters automatically ignore empty or nil values:
-
-```ruby
-filter = Kiroshi::Filter.new(:name)
-filter.apply(Document.all, { name: nil })        # Returns original scope
-filter.apply(Document.all, { name: '' })         # Returns original scope  
-filter.apply(Document.all, {})                   # Returns original scope
-filter.apply(Document.all, { name: 'value' })    # Applies filter
-```
-
-#### Handling Column Name Ambiguity
-
-When working with joined tables that have columns with the same name, use the `table` parameter to specify which table's column to filter:
-
-```ruby
-# Without table specification - may cause ambiguity
-scope = Document.joins(:tags)  # Both documents and tags have 'name' column
-
-# Specify which table to filter on
-name_filter = Kiroshi::Filter.new(:name, match: :like, table: :tags)
-result = name_filter.apply(scope, { name: 'ruby' })
-# Generates: WHERE tags.name LIKE '%ruby%'
-
-# Or filter by document name specifically
-doc_name_filter = Kiroshi::Filter.new(:name, match: :like, table: :documents)
-result = doc_name_filter.apply(scope, { name: 'guide' })
-# Generates: WHERE documents.name LIKE '%guide%'
-```
-
-**Priority**: When using `Kiroshi::Filters`, if a filter specifies a `table`, it takes priority over the scope's default table name.
+For detailed API documentation, see the [YARD documentation](https://www.rubydoc.info/gems/kiroshi/0.2.0).

data/lib/kiroshi/filter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Kiroshi
+  # @api private
   # @author darthjee
   #
   # A filter class that applies filtering logic to ActiveRecord scopes
@@ -10,11 +11,15 @@ module Kiroshi
   #
   # @example Creating and applying an exact filter
   #   filter = Kiroshi::Filter.new(:name)
-  #   filtered_scope = filter.apply(Document.all, { name: 'John' })
+  #   filtered_scope = filter.apply(scope: Document.all, value: 'John')
   #
   # @example Creating and applying a LIKE filter
   #   filter = Kiroshi::Filter.new(:title, match: :like)
-  #   filtered_scope = filter.apply(Article.all, { title: 'Ruby' })
+  #   filtered_scope = filter.apply(scope: Article.all, value: 'Ruby')
+  #
+  # @example Creating and applying a filter with specific value
+  #   filter = Kiroshi::Filter.new(:status)
+  #   filtered_scope = filter.apply(scope: Document.all, value: 'published')
   #
   # @since 0.1.0
   class Filter
@@ -67,43 +72,43 @@ module Kiroshi
 
     # Applies the filter to the given scope
     #
-    # This method examines the filters hash for a value corresponding to the
-    # filter's attribute and applies the appropriate WHERE clause to the scope.
-    # If no value is present or the value is blank, the original scope is returned unchanged.
+    # This method applies the appropriate WHERE clause to the scope using the
+    # provided value. If no value is present or the value is blank, the original
+    # scope is returned unchanged.
     #
     # @param scope [ActiveRecord::Relation] the ActiveRecord scope to filter
-    # @param filters [Hash] a hash containing filter values
+    # @param value [Object, nil] the value to use for filtering, defaults to nil
     #
     # @return [ActiveRecord::Relation] the filtered scope
     #
     # @example Applying an exact filter
     #   filter = Kiroshi::Filter.new(:status)
-    #   filter.apply(Document.all, { status: 'published' })
+    #   filter.apply(scope: Document.all, value: 'published')
     #   # Generates: WHERE status = 'published'
     #
     # @example Applying a LIKE filter
     #   filter = Kiroshi::Filter.new(:title, match: :like)
-    #   filter.apply(Article.all, { title: 'Ruby' })
+    #   filter.apply(scope: Article.all, value: 'Ruby')
     #   # Generates: WHERE title LIKE '%Ruby%'
     #
     # @example Applying a filter with table qualification
     #   filter = Kiroshi::Filter.new(:name, table: 'documents')
-    #   filter.apply(Document.joins(:tags), { name: 'report' })
+    #   filter.apply(scope: Document.joins(:tags), value: 'report')
     #   # Generates: WHERE documents.name = 'report'
     #
     # @example Applying a filter with table qualification for tags
     #   filter = Kiroshi::Filter.new(:name, table: 'tags')
-    #   filter.apply(Document.joins(:tags), { name: 'ruby' })
+    #   filter.apply(scope: Document.joins(:tags), value: 'ruby')
     #   # Generates: WHERE tags.name = 'ruby'
     #
     # @example With empty filter value
     #   filter = Kiroshi::Filter.new(:name)
-    #   filter.apply(User.all, { name: nil })
+    #   filter.apply(scope: User.all, value: nil)
     #   # Returns the original scope unchanged
     #
-    # @since 0.1.0
-    def apply(scope, filters)
-      runner = FilterRunner.new(filter: self, scope: scope, filters: filters)
+    # @since 0.2.0
+    def apply(scope:, value: nil)
+      runner = FilterRunner.new(filter: self, scope: scope, value: value)
       runner.apply
     end
   end

data/lib/kiroshi/filter_query/exact.rb

@@ -31,7 +31,7 @@ module Kiroshi
       #
       # @since 0.1.1
       def apply
-        scope.where(table_name => { attribute => filter_value })
+        scope.where(table_name => { attribute => value })
       end
     end
   end

data/lib/kiroshi/filter_query/like.rb

@@ -34,7 +34,7 @@ module Kiroshi
       def apply
         scope.where(
           "#{table_name}.#{attribute} LIKE ?",
-          "%#{filter_value}%"
+          "%#{value}%"
         )
       end
     end

data/lib/kiroshi/filter_query.rb

@@ -94,38 +94,34 @@ module Kiroshi
     #
     #   @return [Kiroshi::FilterRunner] the filter runner instance
 
-    delegate :scope, :attribute, :table_name, :filter_value, to: :filter_runner
+    delegate :scope, :attribute, :table_name, :value, to: :filter_runner
 
     # @!method scope
     #   @api private
-    #   @private
     #
-    #   Returns the ActiveRecord scope being filtered
+    #   Returns the current scope being filtered
     #
-    #   @return [ActiveRecord::Relation] the scope being filtered
+    #   @return [ActiveRecord::Relation] the scope
 
     # @!method attribute
     #   @api private
-    #   @private
     #
     #   Returns the attribute name to filter by
     #
-    #   @return [Symbol] the attribute name to filter by
+    #   @return [Symbol] the attribute name
 
     # @!method table_name
     #   @api private
-    #   @private
     #
-    #   Returns the table name from the scope
+    #   Returns the table name for the filter
     #
     #   @return [String] the table name
 
-    # @!method filter_value
+    # @!method value
     #   @api private
-    #   @private
     #
-    #   Returns the filter value for the current filter's attribute
+    #   Returns the filter value
     #
-    #   @return [Object, nil] the filter value or nil if not present
+    #   @return [Object] the filter value
   end
 end

data/lib/kiroshi/filter_runner.rb

@@ -12,7 +12,12 @@ module Kiroshi
   #
   # @example Creating and running a filter
   #   filter = Kiroshi::Filter.new(:name, match: :like)
-  #   runner = Kiroshi::FilterRunner.new(filter: filter, scope: User.all, filters: { name: 'John' })
+  #   runner = Kiroshi::FilterRunner.new(filter: filter, scope: User.all, value: 'John')
+  #   result = runner.apply
+  #
+  # @example Creating and running a filter with specific value
+  #   filter = Kiroshi::Filter.new(:status)
+  #   runner = Kiroshi::FilterRunner.new(filter: filter, scope: User.all, value: 'active')
   #   result = runner.apply
   #
   # @since 0.1.0
@@ -21,13 +26,13 @@ module Kiroshi
     #
     # @param filter [Kiroshi::Filter] the filter configuration
     # @param scope [ActiveRecord::Relation] the scope to filter
-    # @param filters [Hash] a hash containing filter values
+    # @param value [Object, nil] the specific value to use for filtering, defaults to nil
     #
-    # @since 0.1.0
-    def initialize(filter:, scope:, filters:)
+    # @since 0.2.0
+    def initialize(filter:, scope:, value: nil)
       @filter = filter
       @scope = scope
-      @filters = filters
+      @value = value
     end
 
     # Applies the filter logic to the scope
@@ -38,41 +43,49 @@ module Kiroshi
     # @return [ActiveRecord::Relation] the filtered scope
     #
     # @example Applying exact match filter
-    #   runner = FilterRunner.new(filter: filter, scope: scope, filters: { name: 'John' })
+    #   runner = FilterRunner.new(filter: filter, scope: scope, value: 'John')
     #   runner.apply
     #
     # @example Applying LIKE filter
-    #   runner = FilterRunner.new(filter: filter, scope: scope, filters: { title: 'Ruby' })
+    #   runner = FilterRunner.new(filter: filter, scope: scope, value: 'Ruby')
+    #   runner.apply
+    #
+    # @example With specific value provided
+    #   runner = FilterRunner.new(filter: filter, scope: scope, value: 'specific_value')
     #   runner.apply
     #
-    # @example With no matching value
-    #   runner = FilterRunner.new(filter: filter, scope: scope, filters: { name: nil })
+    # @example With no value (returns unchanged scope)
+    #   runner = FilterRunner.new(filter: filter, scope: scope, value: nil)
     #   runner.apply
     #   # Returns the original scope unchanged
     #
     # @since 0.1.1
     def apply
-      return scope unless filter_value.present?
+      return scope unless value.present?
 
       query_strategy = FilterQuery.for(filter.match).new(self)
       query_strategy.apply
     end
 
-    # Returns the filter value for the current filter's attribute
+    attr_reader :scope, :value
+
+    # @!method scope
+    #   @api private
     #
-    # @return [Object, nil] the filter value or nil if not present
+    #   Returns the current scope being filtered
     #
-    # @since 0.1.1
-    def filter_value
-      filters[filter.attribute]
-    end
+    #   @return [ActiveRecord::Relation] the scope
+    #
+    #   @since 0.1.1
 
-    # Returns the current scope being filtered
+    # @!method value
+    #   @api private
     #
-    # @return [ActiveRecord::Relation] the scope
+    #   Returns the filter value for the current filter
     #
-    # @since 0.1.1
-    attr_reader :scope
+    #   @return [Object] the filter value or nil if not present
+    #
+    #   @since 0.2.0
 
     # Returns the table name to use for the filter
     #
@@ -84,12 +97,12 @@ module Kiroshi
     #
     # @example With filter table_name specified
     #   filter = Kiroshi::Filter.new(:name, table: 'tags')
-    #   runner = FilterRunner.new(filter: filter, scope: Document.joins(:tags), filters: {})
+    #   runner = FilterRunner.new(filter: filter, scope: Document.joins(:tags), value: 'ruby')
     #   runner.table_name # => 'tags'
     #
     # @example Without filter table_name (fallback to scope)
     #   filter = Kiroshi::Filter.new(:name)
-    #   runner = FilterRunner.new(filter: filter, scope: Document.all, filters: {})
+    #   runner = FilterRunner.new(filter: filter, scope: Document.all, value: 'test')
     #   runner.table_name # => 'documents'
     #
     # @since 0.1.1
@@ -104,9 +117,16 @@ module Kiroshi
     #
     #   @return [ActiveRecord::Relation] the scope
 
+    # @!method value
+    #   @api private
+    #
+    #   Returns the filter value for the current filter
+    #
+    #   @return [Object, nil] the filter value or nil if not present
+
     private
 
-    attr_reader :filter, :filters
+    attr_reader :filter
 
     # @!method filter
     #   @api private
@@ -116,14 +136,6 @@ module Kiroshi
     #
     #   @return [Kiroshi::Filter] the filter configuration
 
-    # @!method filters
-    #   @api private
-    #   @private
-    #
-    #   Returns the hash of filter values
-    #
-    #   @return [Hash] the hash of filter values
-
     delegate :attribute, to: :filter
     delegate :table_name, to: :scope, prefix: true
     delegate :table_name, to: :filter, prefix: true

data/lib/kiroshi/filters/class_methods.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Kiroshi
+  class Filters
+    # @api public
+    # Class-level methods for configuring filters in Kiroshi::Filters
+    #
+    # This module provides the DSL methods that allow filter classes to
+    # define their filtering behavior using class-level method calls.
+    # These methods are automatically available when extending Kiroshi::Filters.
+    #
+    # The primary interface is the {.filter_by} method, which registers
+    # filters that will be applied when {Filters#apply} is called on
+    # instances of the filter class.
+    #
+    # @example Basic filter configuration
+    #   class DocumentFilters < Kiroshi::Filters
+    #     filter_by :name, match: :like
+    #     filter_by :status
+    #     filter_by :category, table: :documents
+    #   end
+    #
+    # @example Accessing filter configurations
+    #   DocumentFilters.filter_configs.keys # => [:name, :status, :category]
+    #   DocumentFilters.filter_configs[:name].match # => :like
+    #
+    # @since 0.2.0
+    # @author darthjee
+    module ClassMethods
+      # Defines a filter for the current filter class
+      #
+      # This method is used at the class level to configure filters that will
+      # be applied when {Filters#apply} is called. Each call creates a new {Filter}
+      # instance with the specified configuration and stores it in the class's
+      # filter registry for later use during filtering operations.
+      #
+      # The method supports various matching strategies and table qualification
+      # options to handle complex database queries with joins and ambiguous
+      # column names.
+      #
+      # @overload filter_by(attribute, **options)
+      #   @param attribute [Symbol] the attribute name to filter by
+      #   @param options [Hash] additional options passed to {Filter#initialize}
+      #   @option options [Symbol] :match (:exact) the matching type
+      #     - +:exact+ for exact matching (default)
+      #     - +:like+ for partial matching using SQL LIKE with wildcards
+      #   @option options [String, Symbol, nil] :table (nil) the table name to qualify the attribute
+      #     when dealing with joined tables that have conflicting column names
+      #
+      # @return (see Filters.filter_by)
+      # @example (see Filters.filter_by)
+      # @note (see Filters.filter_by)
+      # @see (see Filters.filter_by)
+      # @since (see Filters.filter_by)
+      def filter_by(attribute, **)
+        Filter.new(attribute, **).tap do |filter|
+          filter_configs[attribute] = filter
+        end
+      end
+
+      # @api private
+      # Returns the filter configuration for a specific attribute
+      #
+      # This method provides a convenient way to retrieve a specific filter
+      # by its attribute name. It's a shorthand for accessing the filter_configs
+      # hash directly and is used internally by the filtering system.
+      #
+      # @param attribute [Symbol] the attribute name to look up
+      #
+      # @return [Filter, nil] the filter instance for the given attribute,
+      #   or nil if no filter is configured for that attribute
+      #
+      # @example Retrieving a specific filter
+      #   class MyFilters < Kiroshi::Filters
+      #     filter_by :name, match: :like
+      #     filter_by :status
+      #   end
+      #
+      #   MyFilters.filter_for(:name)    # => #<Kiroshi::Filter:0x... @attribute=:name @match=:like>
+      #   MyFilters.filter_for(:status)  # => #<Kiroshi::Filter:0x... @attribute=:status @match=:exact>
+      #   MyFilters.filter_for(:unknown) # => nil
+      #
+      # @see .filter_configs for accessing the complete filter registry
+      # @see Filters#apply for how this method is used during filtering
+      #
+      # @since 0.2.0
+      def filter_for(attribute)
+        filter_configs[attribute] || inherited_filter_for(attribute)
+      end
+
+      private
+
+      # @api private
+      # @private
+      #
+      # Searches for a filter in the inheritance chain
+      #
+      # This method looks up the inheritance chain to find a filter configuration
+      # for the given attribute. It only searches in superclasses that inherit
+      # from Kiroshi::Filters, stopping when it reaches a non-Filters class.
+      #
+      # @param attribute [Symbol] the attribute name to look up
+      # @return [Filter, nil] the filter instance from a parent class, or nil if not found
+      #
+      # @since 0.2.0
+      def inherited_filter_for(attribute)
+        return nil unless superclass < Kiroshi::Filters
+
+        superclass.filter_for(attribute)
+      end
+
+      # @api private
+      # @private
+      #
+      # Returns the hash of configured filters for this filter class
+      #
+      # This method provides access to the internal registry of filters
+      # that have been configured using {.filter_by}. The returned hash
+      # contains {Filter} instances keyed by their attribute names, allowing
+      # for efficient O(1) lookup during filter application.
+      #
+      # This method is primarily used internally by {Filters#apply} to
+      # iterate through and apply all configured filters to a scope.
+      # While marked as private API, it may be useful for introspection
+      # and testing purposes.
+      #
+      # @return [Hash<Symbol, Filter>] hash of {Filter} instances configured
+      #   for this filter class, keyed by attribute name for efficient access
+      #
+      # @example Accessing configured filters for introspection
+      #   class MyFilters < Kiroshi::Filters
+      #     filter_by :name, match: :like
+      #     filter_by :status
+      #     filter_by :category, table: :categories
+      #   end
+      #
+      #   MyFilters.filter_configs.length                    # => 3
+      #   MyFilters.filter_configs.keys                      # => [:name, :status, :category]
+      #   MyFilters.filter_configs[:name].attribute          # => :name
+      #   MyFilters.filter_configs[:name].match              # => :like
+      #   MyFilters.filter_configs[:status].match            # => :exact
+      #   MyFilters.filter_configs[:category].table_name     # => :categories
+      #
+      # @example Using in tests to verify filter configuration
+      #   RSpec.describe ProductFilters do
+      #     it 'configures the expected filters' do
+      #       expect(described_class.filter_configs).to have_key(:name)
+      #       expect(described_class.filter_configs[:name].match).to eq(:like)
+      #     end
+      #   end
+      #
+      # @note This method returns a reference to the actual internal hash.
+      #   Modifying the returned hash directly will affect the filter class
+      #   configuration. Use {.filter_by} for proper filter registration.
+      #
+      # @note The hash is lazily initialized on first access and persists
+      #   for the lifetime of the class. Each filter class maintains its
+      #   own separate filter_configs hash.
+      #
+      # @see .filter_by for adding filters to this configuration
+      # @see Filters#apply for how these configurations are used
+      #
+      # @since 0.2.0
+      def filter_configs
+        @filter_configs ||= {}
+      end
+    end
+  end
+end

data/lib/kiroshi/filters.rb

@@ -36,73 +36,69 @@ module Kiroshi
   #
   # @since 0.1.0
   class Filters
-    class << self
-      # Defines a filter for the current filter class
-      #
-      # This method is used at the class level to configure filters that will
-      # be applied when {#apply} is called. Each call creates a new {Filter}
-      # instance with the specified configuration.
-      #
-      # @overload filter_by(attribute, **options)
-      #   @param attribute [Symbol] the attribute name to filter by
-      #   @param options [Hash] additional options passed to {Filter#initialize}
-      #   @option options [Symbol] :match (:exact) the matching type
-      #     - +:exact+ for exact matching (default)
-      #     - +:like+ for partial matching using SQL LIKE
-      #   @option options [String, Symbol, nil] :table (nil) the table name to qualify the attribute
-      #
-      # @return [Filter] the new filter instance
-      #
-      # @example Defining exact match filters
-      #   class ProductFilters < Kiroshi::Filters
-      #     filter_by :category
-      #     filter_by :brand
-      #   end
-      #
-      # @example Defining partial match filters
-      #   class SearchFilters < Kiroshi::Filters
-      #     filter_by :title, match: :like
-      #     filter_by :description, match: :like
-      #   end
-      #
-      # @example Mixed filter types
-      #   class OrderFilters < Kiroshi::Filters
-      #     filter_by :customer_name, match: :like
-      #     filter_by :status, match: :exact
-      #     filter_by :payment_method
-      #   end
-      #
-      # @example Filter with table qualification
-      #   class DocumentTagFilters < Kiroshi::Filters
-      #     filter_by :name, table: :tags
-      #   end
-      #
-      # @since 0.1.0
-      def filter_by(attribute, **)
-        Filter.new(attribute, **).tap do |filter|
-          filter_configs << filter
-        end
-      end
+    autoload :ClassMethods, 'kiroshi/filters/class_methods'
 
-      # Returns the list of configured filters for this class
-      #
-      # @return [Array<Filter>] array of {Filter} instances configured
-      #   for this filter class
-      #
-      # @example Accessing configured filters
-      #   class MyFilters < Kiroshi::Filters
-      #     filter_by :name
-      #     filter_by :status, match: :like
-      #   end
-      #
-      #   MyFilters.filter_configs.length # => 2
-      #   MyFilters.filter_configs.first.attribute # => :name
-      #
-      # @since 0.1.0
-      def filter_configs
-        @filter_configs ||= []
-      end
-    end
+    extend ClassMethods
+
+    # @method self.filter_by(attribute, **options)
+    #   @api public
+    #   @param attribute [Symbol] the attribute name to filter by
+    #   @param options [Hash] additional options passed to {Filter#initialize}
+    #   @option options [Symbol] :match (:exact) the matching type
+    #     - +:exact+ for exact matching (default)
+    #     - +:like+ for partial matching using SQL LIKE with wildcards
+    #   @option options [String, Symbol, nil] :table (nil) the table name to qualify the attribute
+    #     when dealing with joined tables that have conflicting column names
+    #
+    #   @return [Filter] the new filter instance that was created and registered
+    #
+    #   @example Defining exact match filters
+    #     class ProductFilters < Kiroshi::Filters
+    #       filter_by :category      # Exact match on category
+    #       filter_by :brand         # Exact match on brand
+    #       filter_by :active        # Exact match on active status
+    #     end
+    #
+    #   @example Defining partial match filters
+    #     class SearchFilters < Kiroshi::Filters
+    #       filter_by :title, match: :like         # Partial match on title
+    #       filter_by :description, match: :like   # Partial match on description
+    #       filter_by :author_name, match: :like   # Partial match on author name
+    #     end
+    #
+    #   @example Mixed filter types with different matching strategies
+    #     class OrderFilters < Kiroshi::Filters
+    #       filter_by :customer_name, match: :like  # Partial match for customer search
+    #       filter_by :status, match: :exact        # Exact match for order status
+    #       filter_by :payment_method               # Exact match (default) for payment
+    #     end
+    #
+    #   @example Filters with table qualification for joined queries
+    #     class DocumentTagFilters < Kiroshi::Filters
+    #       filter_by :name, table: :documents      # Filter by document name
+    #       filter_by :tag_name, table: :tags       # Filter by tag name
+    #       filter_by :category, table: :categories # Filter by category name
+    #     end
+    #
+    #   @example Complex real-world filter class
+    #     class ProductSearchFilters < Kiroshi::Filters
+    #       filter_by :name, match: :like                    # Product name search
+    #       filter_by :category_id                           # Exact category match
+    #       filter_by :brand, match: :like                   # Brand name search
+    #       filter_by :price_min                             # Minimum price
+    #       filter_by :price_max                             # Maximum price
+    #       filter_by :in_stock                              # Availability filter
+    #       filter_by :category_name, table: :categories     # Category name via join
+    #     end
+    #
+    #   @note When using table qualification, ensure that the specified table
+    #     is properly joined in the scope being filtered. The filter will not
+    #     automatically add joins - it only qualifies the column name.
+    #
+    #   @see Filter#initialize for detailed information about filter options
+    #   @see Filters#apply for how these filters are used during query execution
+    #
+    #   @since 0.1.0
 
     # Creates a new Filters instance
     #
@@ -160,10 +156,13 @@ module Kiroshi
     #   filtered_articles = filters.apply(Article.all)
     #   # Generates: WHERE title LIKE '%Ruby%'
     #
-    # @since 0.1.0
+    # @since 0.2.0
     def apply(scope)
-      self.class.filter_configs.each do |filter|
-        scope = filter.apply(scope, filters)
+      filters.compact.each do |attribute, value|
+        filter = self.class.filter_for(attribute)
+        next unless filter
+
+        scope = filter.apply(scope: scope, value: value)
       end
 
       scope

data/lib/kiroshi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kiroshi
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/kiroshi.rb

@@ -9,9 +9,10 @@
 # using a declarative DSL. It supports multiple matching strategies and can
 # be easily integrated into Rails controllers and other components.
 #
-# The gem is designed around two main concepts:
+# The gem is designed around the main concept:
 # - {Filters}: A base class for creating reusable filter sets
-# - {Filter}: Individual filters that can be applied to scopes
+#
+# Individual filters are handled internally and don't require direct interaction.
 #
 # @example Basic filter class definition
 #   class DocumentFilters < Kiroshi::Filters
@@ -68,25 +69,6 @@
 #   filtered_users = filters.apply(User.includes(:department))
 #   # Generates: WHERE email LIKE '%admin%' AND role = 'moderator' AND active = true
 #
-# @example Individual filter usage
-#   # Create standalone filters
-#   name_filter = Kiroshi::Filter.new(:name, match: :like)
-#   status_filter = Kiroshi::Filter.new(:status)
-#
-#   # Apply filters step by step
-#   scope = Document.all
-#   scope = name_filter.apply(scope, { name: 'annual' })
-#   scope = status_filter.apply(scope, { status: 'published' })
-#
-# @example Filter matching types
-#   # Exact matching (default)
-#   Kiroshi::Filter.new(:status)
-#   # Generates: WHERE status = 'value'
-#
-#   # Partial matching with LIKE
-#   Kiroshi::Filter.new(:title, match: :like)
-#   # Generates: WHERE title LIKE '%value%'
-#
 # @example Empty value handling
 #   filters = DocumentFilters.new(name: '', status: 'published')
 #   result = filters.apply(Document.all)
@@ -148,7 +130,6 @@
 #   end
 #
 # @see Filters Base class for creating filter sets
-# @see Filter Individual filter implementation
 # @see https://github.com/darthjee/kiroshi GitHub repository
 # @see https://www.rubydoc.info/gems/kiroshi YARD documentation
 #

data/spec/lib/kiroshi/filter_query/exact_spec.rb

@@ -6,11 +6,10 @@ RSpec.describe Kiroshi::FilterQuery::Exact, type: :model do
   describe '#apply' do
     subject(:query) { described_class.new(filter_runner) }
 
-    let(:filter_runner) { Kiroshi::FilterRunner.new(filter: filter, scope: scope, filters: filters) }
+    let(:filter_runner) { Kiroshi::FilterRunner.new(filter: filter, scope: scope, value: filter_value) }
     let(:filter)        { Kiroshi::Filter.new(:name, match: :exact) }
     let(:scope)         { Document.all }
     let(:filter_value)  { 'test_document' }
-    let(:filters)       { { name: filter_value } }
 
     let!(:matching_document)     { create(:document, name: 'test_document') }
     let!(:non_matching_document) { create(:document, name: 'other_document') }
@@ -36,7 +35,6 @@ RSpec.describe Kiroshi::FilterQuery::Exact, type: :model do
     context 'when filtering by status attribute' do
       let(:filter)        { Kiroshi::Filter.new(:status, match: :exact) }
       let(:filter_value)  { 'published' }
-      let(:filters)       { { status: filter_value } }
 
       let!(:published_document) { create(:document, status: 'published') }
       let!(:draft_document)     { create(:document, status: 'draft') }
@@ -63,7 +61,6 @@ RSpec.describe Kiroshi::FilterQuery::Exact, type: :model do
     context 'when filtering with numeric values' do
       let(:filter)        { Kiroshi::Filter.new(:priority, match: :exact) }
       let(:filter_value)  { 1 }
-      let(:filters)       { { priority: filter_value } }
 
       let!(:high_priority_document)   { create(:document, priority: 1) }
       let!(:medium_priority_document) { create(:document, priority: 2) }
@@ -90,7 +87,6 @@ RSpec.describe Kiroshi::FilterQuery::Exact, type: :model do
     context 'when filtering with boolean values' do
       let(:filter)        { Kiroshi::Filter.new(:active, match: :exact) }
       let(:filter_value)  { true }
-      let(:filters)       { { active: filter_value } }
 
       let!(:active_document)   { create(:document, active: true) }
       let!(:inactive_document) { create(:document, active: false) }
@@ -154,7 +150,6 @@ RSpec.describe Kiroshi::FilterQuery::Exact, type: :model do
     context 'when filter has table configured' do
       let(:scope) { Document.joins(:tags) }
       let(:filter_value) { 'ruby' }
-      let(:filters)      { { name: filter_value } }
 
       let!(:first_tag) { Tag.find_or_create_by(name: 'ruby') }
       let!(:second_tag)  { Tag.find_or_create_by(name: 'javascript') }
@@ -252,7 +247,6 @@ RSpec.describe Kiroshi::FilterQuery::Exact, type: :model do
       context 'when filtering by different attributes with table qualification' do
         let(:filter)       { Kiroshi::Filter.new(:id, match: :exact, table: :tags) }
         let(:filter_value) { first_tag.id }
-        let(:filters)      { { id: filter_value } }
 
         let(:expected_sql) do
           <<~SQL.squish

data/spec/lib/kiroshi/filter_query/like_spec.rb

@@ -6,11 +6,10 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
   describe '#apply' do
     subject(:query) { described_class.new(filter_runner) }
 
-    let(:filter_runner) { Kiroshi::FilterRunner.new(filter: filter, scope: scope, filters: filters) }
+    let(:filter_runner) { Kiroshi::FilterRunner.new(filter: filter, scope: scope, value: filter_value) }
     let(:filter)        { Kiroshi::Filter.new(:name, match: :like) }
     let(:scope)         { Document.all }
     let(:filter_value)  { 'test' }
-    let(:filters)       { { name: filter_value } }
 
     let!(:matching_document)     { create(:document, name: 'test_document') }
     let!(:another_match)         { create(:document, name: 'my_test_file') }
@@ -41,7 +40,6 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
     context 'when filtering by status attribute' do
       let(:filter)        { Kiroshi::Filter.new(:status, match: :like) }
       let(:filter_value)  { 'pub' }
-      let(:filters)       { { status: filter_value } }
 
       let!(:published_document)     { create(:document, status: 'published') }
       let!(:republished_document)   { create(:document, status: 'republished') }
@@ -73,7 +71,6 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
     context 'when filtering with numeric values as strings' do
       let(:filter)        { Kiroshi::Filter.new(:version, match: :like) }
       let(:filter_value)  { '1.2' }
-      let(:filters)       { { version: filter_value } }
 
       let!(:version_match)     { create(:document, version: '1.2.3') }
       let!(:another_version)   { create(:document, version: '2.1.2') }
@@ -190,7 +187,6 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
     context 'when filter has table configured' do
       let(:scope) { Document.joins(:tags) }
       let(:filter_value) { 'ruby' }
-      let(:filters)      { { name: filter_value } }
 
       let!(:first_tag) { Tag.find_or_create_by(name: 'ruby') }
       let!(:second_tag) { Tag.find_or_create_by(name: 'ruby_on_rails') }

data/spec/lib/kiroshi/filter_runner_spec.rb

@@ -4,12 +4,12 @@ require 'spec_helper'
 
 RSpec.describe Kiroshi::FilterRunner, type: :model do
   describe '#apply' do
-    subject(:runner) { described_class.new(filter: filter, scope: scope, filters: filters) }
+    subject(:runner) { described_class.new(filter: filter, scope: scope, value: filter_value) }
 
     let(:scope)                  { Document.all }
     let(:filter_value)           { 'test_value' }
-    let(:filters)                { { name: filter_value } }
-    let!(:matching_document)     { create(:document, name: filter_value) }
+    let(:document_name)          { filter_value }
+    let!(:matching_document)     { create(:document, name: document_name) }
     let!(:non_matching_document) { create(:document, name: 'other_value') }
 
     context 'when filter match is :exact' do
@@ -57,8 +57,9 @@ RSpec.describe Kiroshi::FilterRunner, type: :model do
     end
 
     context 'when filter value is not present' do
-      let(:filter)  { Kiroshi::Filter.new(:name) }
-      let(:filters) { { name: nil } }
+      let(:document_name) { 'Some name' }
+      let(:filter)        { Kiroshi::Filter.new(:name) }
+      let(:filter_value)  { nil }
 
       it 'returns the original scope unchanged' do
         expect(runner.apply).to eq(scope)
@@ -66,35 +67,18 @@ RSpec.describe Kiroshi::FilterRunner, type: :model do
     end
 
     context 'when filter value is empty string' do
-      let(:filter) { Kiroshi::Filter.new(:name) }
-      let(:filters) { { name: '' } }
-
-      it 'returns the original scope unchanged' do
-        expect(runner.apply).to eq(scope)
-      end
-    end
-
-    context 'when filter attribute is not in filters hash' do
-      let(:filter) { Kiroshi::Filter.new(:status) }
-      let(:filters) { { name: 'test_value' } }
-
-      it 'returns the original scope unchanged' do
-        expect(runner.apply).to eq(scope)
-      end
-    end
-
-    context 'when filters hash is empty' do
-      let(:filter) { Kiroshi::Filter.new(:name) }
-      let(:filters) { {} }
+      let(:document_name) { 'Some name' }
+      let(:filter)       { Kiroshi::Filter.new(:name) }
+      let(:filter_value) { '' }
 
       it 'returns the original scope unchanged' do
         expect(runner.apply).to eq(scope)
       end
     end
 
-    context 'with multiple attributes' do
-      let(:filter) { Kiroshi::Filter.new(:status, match: :exact) }
-      let(:filters)                { { name: 'test_name', status: 'finished' } }
+    context 'with status filter' do
+      let(:filter)                 { Kiroshi::Filter.new(:status, match: :exact) }
+      let(:filter_value)           { 'finished' }
       let!(:matching_document)     { create(:document, name: 'test_name', status: 'finished') }
       let!(:non_matching_document) { create(:document, name: 'other_name', status: 'processing') }
 

data/spec/lib/kiroshi/filter_spec.rb

@@ -6,19 +6,18 @@ RSpec.describe Kiroshi::Filter, type: :model do
   describe '#apply' do
     let(:scope)                  { Document.all }
     let(:filter_value)           { 'test_value' }
-    let(:filters)                { { name: filter_value } }
     let!(:matching_document)     { create(:document, name: filter_value) }
     let!(:non_matching_document) { create(:document, name: 'other_value') }
 
     context 'when match is :exact' do
       subject(:filter) { described_class.new(:name, match: :exact) }
 
-      it 'returns exact matches' do
-        expect(filter.apply(scope, filters)).to include(matching_document)
+      it 'returns documents matching the filter' do
+        expect(filter.apply(scope: scope, value: filter_value)).to include(matching_document)
       end
 
-      it 'does not return non-matching records' do
-        expect(filter.apply(scope, filters)).not_to include(non_matching_document)
+      it 'does not return documents not matching the filter' do
+        expect(filter.apply(scope: scope, value: filter_value)).not_to include(non_matching_document)
       end
     end
 
@@ -30,11 +29,11 @@ RSpec.describe Kiroshi::Filter, type: :model do
       let!(:non_matching_document) { create(:document, name: 'other_value') }
 
       it 'returns partial matches' do
-        expect(filter.apply(scope, filters)).to include(matching_document)
+        expect(filter.apply(scope: scope, value: filter_value)).to include(matching_document)
       end
 
       it 'does not return non-matching records' do
-        expect(filter.apply(scope, filters)).not_to include(non_matching_document)
+        expect(filter.apply(scope: scope, value: filter_value)).not_to include(non_matching_document)
       end
     end
 
@@ -42,21 +41,19 @@ RSpec.describe Kiroshi::Filter, type: :model do
       subject(:filter) { described_class.new(:name) }
 
       it 'defaults to exact match returning only exact matches' do
-        expect(filter.apply(scope, filters)).to include(matching_document)
+        expect(filter.apply(scope: scope, value: filter_value)).to include(matching_document)
       end
 
       it 'defaults to exact match returning not returning when filtering by a non-matching value' do
-        expect(filter.apply(scope, filters)).not_to include(non_matching_document)
+        expect(filter.apply(scope: scope, value: filter_value)).not_to include(non_matching_document)
       end
     end
 
     context 'when filter value is not present' do
       subject(:filter) { described_class.new(:name) }
 
-      let(:filters) { { name: nil } }
-
       it 'returns the original scope unchanged' do
-        expect(filter.apply(scope, filters)).to eq(scope)
+        expect(filter.apply(scope: scope, value: nil)).to eq(scope)
       end
     end
   end

data/spec/lib/kiroshi/filters/class_methods_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kiroshi::Filters::ClassMethods, type: :model do
+  subject(:filters_class) { Class.new(Kiroshi::Filters) }
+
+  let(:filter_instance) { filters_class.new(filters) }
+  let(:scope)           { Document.all }
+  let(:filters)         { {} }
+
+  describe '.filter_by' do
+    let(:scope)   { Document.all }
+    let(:filters) { { name: name } }
+    let(:name)    { 'test_name' }
+
+    context 'when adding a new filter' do
+      it do
+        expect { filters_class.filter_by :name }
+          .to change { filter_instance.apply(scope) }
+          .from(scope).to(scope.where(name: name))
+      end
+    end
+
+    context 'when adding a filter with table qualification' do
+      let(:scope) { Document.joins(:tags) }
+
+      it do
+        expect { filters_class.filter_by :name, table: :documents }
+          .to change { filter_instance.apply(scope) }
+          .from(scope).to(scope.where(documents: { name: name }))
+      end
+    end
+
+    context 'when adding a filter with different table' do
+      let(:scope)   { Document.joins(:tags) }
+      let(:filters) { { name: 'ruby' } }
+      let(:name)    { 'ruby' }
+
+      it do
+        expect { filters_class.filter_by :name, table: :tags }
+          .to change { filter_instance.apply(scope) }
+          .from(scope).to(scope.where(tags: { name: name }))
+      end
+    end
+
+    context 'when adding a like filter with table qualification' do
+      let(:scope) { Document.joins(:tags) }
+      let(:filters) { { name: 'test' } }
+      let(:name)    { 'test' }
+
+      it do
+        expect { filters_class.filter_by :name, match: :like, table: :documents }
+          .to change { filter_instance.apply(scope) }
+          .from(scope).to(scope.where('documents.name LIKE ?', '%test%'))
+      end
+    end
+  end
+end

data/spec/lib/kiroshi/filters_spec.rb

@@ -3,16 +3,16 @@
 require 'spec_helper'
 
 RSpec.describe Kiroshi::Filters, type: :model do
-  describe '#apply' do
-    subject(:filter_instance) { filters_class.new(filters) }
+  subject(:filters_class) { Class.new(described_class) }
+
+  let(:filter_instance) { filters_class.new(filters) }
+  let(:scope)           { Document.all }
+  let(:filters)         { {} }
 
-    let(:scope)           { Document.all }
-    let(:filters)         { {} }
+  describe '#apply' do
     let!(:document)       { create(:document, name: 'test_name', status: 'finished') }
     let!(:other_document) { create(:document, name: 'other_name', status: 'processing') }
 
-    let(:filters_class) { Class.new(described_class) }
-
     context 'when no filters are configured' do
       context 'when no filters are provided' do
         it 'returns the original scope unchanged' do
@@ -92,7 +92,7 @@ RSpec.describe Kiroshi::Filters, type: :model do
     end
 
     context 'when scope has joined tables with clashing fields' do
-      let(:scope) { Document.joins(:tags) }
+      let(:scope)   { Document.joins(:tags) }
       let(:filters) { { name: 'test_name' } }
 
       let!(:first_tag) { Tag.find_or_create_by(name: 'ruby') }
@@ -128,7 +128,6 @@ RSpec.describe Kiroshi::Filters, type: :model do
         let(:filters) { { name: 'test' } }
 
         before do
-          filters_class.instance_variable_set(:@filter_configs, [])
           filters_class.filter_by :name, match: :like
         end
 
@@ -153,5 +152,102 @@ RSpec.describe Kiroshi::Filters, type: :model do
         end
       end
     end
+
+    context 'when filter was defined in the superclass' do
+      subject(:filters_class) { Class.new(parent_class) }
+
+      let(:parent_class) { Class.new(described_class) }
+      let(:filters)      { { name: 'test_name' } }
+
+      before do
+        parent_class.filter_by :name
+      end
+
+      it 'applies the filter defined in the parent class' do
+        expect(filter_instance.apply(scope)).to include(document)
+      end
+
+      it 'does not return documents not matching the inherited filter' do
+        expect(filter_instance.apply(scope)).not_to include(other_document)
+      end
+
+      it 'generates SQL that includes the filter value from parent class' do
+        result = filter_instance.apply(scope)
+        expect(result.to_sql).to include("'test_name'")
+      end
+
+      context 'when child class adds its own filter' do
+        let(:filters) { { name: 'test_name', status: 'finished' } }
+
+        before do
+          filters_class.filter_by :status
+        end
+
+        it 'applies both parent and child filters' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not return documents not matching all filters' do
+          expect(filter_instance.apply(scope)).not_to include(other_document)
+        end
+      end
+
+      context 'when child class overrides parent filter' do
+        let(:filters) { { name: 'test' } }
+
+        before do
+          filters_class.filter_by :name, match: :like
+        end
+
+        it 'uses the child class filter configuration' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not use the parent class filter configuration' do
+          expect(filter_instance.apply(scope).to_sql)
+            .to include('LIKE')
+        end
+
+        it 'generates SQL that includes LIKE operation with the filter value' do
+          expect(filter_instance.apply(scope).to_sql)
+            .to include("'%test%'")
+        end
+      end
+
+      context 'when child class overrides parent filter with table qualification' do
+        let(:scope)   { Document.joins(:tags) }
+        let(:filters) { { name: 'ruby' } }
+
+        let!(:ruby_tag) { Tag.find_or_create_by(name: 'ruby') }
+        let!(:js_tag)   { Tag.find_or_create_by(name: 'javascript') }
+
+        before do
+          filters_class.filter_by :name, table: :tags
+
+          document.tags << [ruby_tag]
+          other_document.tags << [js_tag]
+        end
+
+        it 'uses the child class table qualification (tags.name)' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not return documents with different tag names' do
+          expect(filter_instance.apply(scope)).not_to include(other_document)
+        end
+
+        it 'generates SQL that filters by tags.name, not documents.name' do
+          expect(filter_instance.apply(scope).to_sql).to include('"tags"."name"')
+        end
+
+        it 'generates SQL that does not include documents.name' do
+          expect(filter_instance.apply(scope).to_sql).not_to include('"documents"."name"')
+        end
+
+        it 'generates SQL that includes the tag filter value' do
+          expect(filter_instance.apply(scope).to_sql).to include("'ruby'")
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kiroshi
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-18 00:00:00.000000000 Z
+date: 2025-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -70,6 +70,7 @@ files:
 - lib/kiroshi/filter_query/like.rb
 - lib/kiroshi/filter_runner.rb
 - lib/kiroshi/filters.rb
+- lib/kiroshi/filters/class_methods.rb
 - lib/kiroshi/version.rb
 - spec/integration/readme/.keep
 - spec/integration/yard/.keep
@@ -78,6 +79,7 @@ files:
 - spec/lib/kiroshi/filter_query_spec.rb
 - spec/lib/kiroshi/filter_runner_spec.rb
 - spec/lib/kiroshi/filter_spec.rb
+- spec/lib/kiroshi/filters/class_methods_spec.rb
 - spec/lib/kiroshi/filters_spec.rb
 - spec/lib/kiroshi_spec.rb
 - spec/spec_helper.rb