kiroshi 0.1.0 → 0.2.0

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
@@ -90,5 +90,164 @@ RSpec.describe Kiroshi::Filters, type: :model do
         expect(filter_instance.apply(scope)).to eq(scope)
       end
     end
+
+    context 'when scope has joined tables with clashing fields' do
+      let(:scope)   { Document.joins(:tags) }
+      let(:filters) { { name: 'test_name' } }
+
+      let!(:first_tag) { Tag.find_or_create_by(name: 'ruby') }
+      let!(:second_tag) { Tag.find_or_create_by(name: 'programming') }
+
+      before do
+        filters_class.filter_by :name
+        document.tags << [first_tag, second_tag]
+        other_document.tags << [first_tag]
+      end
+
+      it 'filters by document name, not tag name' do
+        result = filter_instance.apply(scope)
+        expect(result).to include(document)
+      end
+
+      it 'does not return documents that do not match document name' do
+        result = filter_instance.apply(scope)
+        expect(result).not_to include(other_document)
+      end
+
+      it 'generates SQL that includes documents table qualification for name field' do
+        result = filter_instance.apply(scope)
+        expect(result.to_sql).to include('"documents"."name"')
+      end
+
+      it 'generates SQL that includes the filter value' do
+        result = filter_instance.apply(scope)
+        expect(result.to_sql).to include("'test_name'")
+      end
+
+      context 'when using like filter' do
+        let(:filters) { { name: 'test' } }
+
+        before do
+          filters_class.filter_by :name, match: :like
+        end
+
+        it 'filters by document name with LIKE operation' do
+          result = filter_instance.apply(scope)
+          expect(result).to include(document)
+        end
+
+        it 'does not return documents that do not match document name pattern' do
+          result = filter_instance.apply(scope)
+          expect(result).not_to include(other_document)
+        end
+
+        it 'generates SQL with table-qualified LIKE operation' do
+          result = filter_instance.apply(scope)
+          expect(result.to_sql).to include('documents.name LIKE')
+        end
+
+        it 'generates SQL with correct LIKE pattern' do
+          result = filter_instance.apply(scope)
+          expect(result.to_sql).to include("'%test%'")
+        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

data/spec/support/db/schema.rb

@@ -6,5 +6,19 @@ ActiveRecord::Schema.define do
   create_table :documents, force: true do |t|
     t.string   :name
     t.string   :status
+    t.boolean  :active
+    t.integer  :priority
+    t.string   :version
+  end
+
+  create_table :tags, force: true do |t|
+    t.string :name, null: false
+    t.index :name, unique: true
+  end
+
+  create_table :documents_tags, force: true do |t|
+    t.references :document, null: false, foreign_key: true
+    t.references :tag, null: false, foreign_key: true
+    t.index %i[document_id tag_id], unique: true
   end
 end

data/spec/support/factories/tag.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :tag, class: '::Tag' do
+    sequence(:name) { |n| "tag-#{n}" }
+  end
+end

data/spec/support/models/document.rb

@@ -2,4 +2,6 @@
 
 class Document < ActiveRecord::Base
   validates :name, presence: true
+
+  has_and_belongs_to_many :tags
 end

data/spec/support/models/tag.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Tag < ActiveRecord::Base
+  validates :name, presence: true, uniqueness: true
+
+  has_and_belongs_to_many :documents
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kiroshi
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-17 00:00:00.000000000 Z
+date: 2025-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -65,19 +65,31 @@ files:
 - kiroshi.jpg
 - lib/kiroshi.rb
 - lib/kiroshi/filter.rb
+- lib/kiroshi/filter_query.rb
+- lib/kiroshi/filter_query/exact.rb
+- 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
+- spec/lib/kiroshi/filter_query/exact_spec.rb
+- spec/lib/kiroshi/filter_query/like_spec.rb
+- 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
 - spec/support/db/schema.rb
 - spec/support/factories/document.rb
+- spec/support/factories/tag.rb
 - spec/support/factory_bot.rb
 - spec/support/models/.keep
 - spec/support/models/document.rb
+- spec/support/models/tag.rb
 - spec/support/shared_examples/.keep
 homepage: https://github.com/darthjee/kiroshi
 licenses: []