kiroshi 0.1.1 → 0.3.0

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
@@ -276,5 +270,45 @@ RSpec.describe Kiroshi::FilterQuery::Exact, type: :model do
         end
       end
     end
+
+    context 'when Filter#column is different from filter_key' do
+      let(:filter) { Kiroshi::Filter.new(:user_name, match: :exact, column: :full_name) }
+      let(:filter_value) { 'John Doe' }
+
+      let!(:matching_document) { create(:document, full_name: 'John Doe') }
+      let!(:non_matching_document) { create(:document, full_name: 'Jane Smith') }
+
+      let(:expected_sql) do
+        <<~SQL.squish
+          SELECT "documents".* FROM "documents" WHERE "documents"."full_name" = 'John Doe'
+        SQL
+      end
+
+      it 'uses the column name instead of filter_key in SQL' do
+        expect(query.apply.to_sql).to eq(expected_sql)
+      end
+
+      it 'returns records that match the column value' do
+        expect(query.apply).to include(matching_document)
+      end
+
+      it 'does not return records that do not match the column value' do
+        expect(query.apply).not_to include(non_matching_document)
+      end
+
+      context 'with table qualification' do
+        let(:filter) { Kiroshi::Filter.new(:user_name, match: :exact, table: :documents, column: :full_name) }
+
+        let(:expected_sql) do
+          <<~SQL.squish
+            SELECT "documents".* FROM "documents" WHERE "documents"."full_name" = 'John Doe'
+          SQL
+        end
+
+        it 'generates SQL with proper table and column qualification' do
+          expect(query.apply.to_sql).to eq(expected_sql)
+        end
+      end
+    end
   end
 end

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') }
@@ -18,7 +17,7 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
 
     let(:expected_sql) do
       <<~SQL.squish
-        SELECT "documents".* FROM "documents" WHERE (documents.name LIKE '%test%')
+        SELECT "documents".* FROM "documents" WHERE ("documents"."name" LIKE '%test%')
       SQL
     end
 
@@ -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') }
@@ -49,7 +47,7 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
 
       let(:expected_sql) do
         <<~SQL.squish
-          SELECT "documents".* FROM "documents" WHERE (documents.status LIKE '%pub%')
+          SELECT "documents".* FROM "documents" WHERE ("documents"."status" LIKE '%pub%')
         SQL
       end
 
@@ -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') }
@@ -81,7 +78,7 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
 
       let(:expected_sql) do
         <<~SQL.squish
-          SELECT "documents".* FROM "documents" WHERE (documents.version LIKE '%1.2%')
+          SELECT "documents".* FROM "documents" WHERE ("documents"."version" LIKE '%1.2%')
         SQL
       end
 
@@ -107,7 +104,7 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
 
       let(:expected_sql) do
         <<~SQL.squish
-          SELECT "documents".* FROM "documents" WHERE (documents.name LIKE '%nonexistent%')
+          SELECT "documents".* FROM "documents" WHERE ("documents"."name" LIKE '%nonexistent%')
         SQL
       end
 
@@ -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') }
@@ -222,7 +218,7 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
 
         it 'generates SQL with tags table qualification' do
           result_sql = query.apply.to_sql
-          expect(result_sql).to include('tags.name LIKE')
+          expect(result_sql).to include('"tags"."name" LIKE')
         end
 
         it 'generates SQL with correct LIKE pattern for tag name' do
@@ -249,7 +245,7 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
 
         it 'generates SQL with documents table qualification' do
           result_sql = query.apply.to_sql
-          expect(result_sql).to include('documents.name LIKE')
+          expect(result_sql).to include('"documents"."name" LIKE')
         end
 
         it 'generates SQL with correct LIKE pattern for document name' do
@@ -267,7 +263,52 @@ RSpec.describe Kiroshi::FilterQuery::Like, type: :model do
 
         it 'generates SQL with string table qualification' do
           result_sql = query.apply.to_sql
-          expect(result_sql).to include('tags.name LIKE')
+          expect(result_sql).to include('"tags"."name" LIKE')
+        end
+      end
+    end
+
+    context 'when Filter#column is different from filter_key' do
+      let(:filter)       { Kiroshi::Filter.new(:user_name, match: :like, column: :full_name) }
+      let(:filter_value) { 'John' }
+
+      let!(:matching_document) { create(:document, full_name: 'John Doe') }
+      let!(:another_match)         { create(:document, full_name: 'Johnny Smith') }
+      let!(:non_matching_document) { create(:document, full_name: 'Jane Wilson') }
+
+      let(:expected_sql) do
+        <<~SQL.squish
+          SELECT "documents".* FROM "documents" WHERE ("documents"."full_name" LIKE '%John%')
+        SQL
+      end
+
+      it 'uses the column name instead of filter_key in SQL' do
+        expect(query.apply.to_sql).to eq(expected_sql)
+      end
+
+      it 'returns records that partially match the column value' do
+        expect(query.apply).to include(matching_document)
+      end
+
+      it 'returns multiple records that contain the column value' do
+        expect(query.apply).to include(another_match)
+      end
+
+      it 'does not return records that do not contain the column value' do
+        expect(query.apply).not_to include(non_matching_document)
+      end
+
+      context 'with table qualification' do
+        let(:filter) { Kiroshi::Filter.new(:user_name, match: :like, table: :documents, column: :full_name) }
+
+        let(:expected_sql) do
+          <<~SQL.squish
+            SELECT "documents".* FROM "documents" WHERE ("documents"."full_name" LIKE '%John%')
+          SQL
+        end
+
+        it 'generates SQL with proper table and column qualification' do
+          expect(query.apply.to_sql).to eq(expected_sql)
         end
       end
     end

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
@@ -39,7 +39,7 @@ RSpec.describe Kiroshi::FilterRunner, type: :model do
       end
 
       it 'generates correct SQL with table name prefix' do
-        expected_sql = "SELECT \"documents\".* FROM \"documents\" WHERE (documents.name LIKE '%test%')"
+        expected_sql = "SELECT \"documents\".* FROM \"documents\" WHERE (\"documents\".\"name\" LIKE '%test%')"
         expect(runner.apply.to_sql).to eq(expected_sql)
       end
     end
@@ -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,45 +67,69 @@ 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: '' } }
+      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 'when filter attribute is not in filters hash' do
-      let(:filter) { Kiroshi::Filter.new(:status) }
-      let(:filters) { { name: 'test_value' } }
+    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') }
 
-      it 'returns the original scope unchanged' do
-        expect(runner.apply).to eq(scope)
+      it 'filters by the configured attribute only returning the matched' do
+        expect(runner.apply).to include(matching_document)
       end
-    end
-
-    context 'when filters hash is empty' do
-      let(:filter) { Kiroshi::Filter.new(:name) }
-      let(:filters) { {} }
 
-      it 'returns the original scope unchanged' do
-        expect(runner.apply).to eq(scope)
+      it 'does not return non-matching records' do
+        expect(runner.apply).not_to include(non_matching_document)
       end
     end
 
-    context 'with multiple attributes' do
-      let(:filter) { Kiroshi::Filter.new(:status, match: :exact) }
-      let(:filters)                { { name: 'test_name', status: 'finished' } }
-      let!(:matching_document)     { create(:document, name: 'test_name', status: 'finished') }
-      let!(:non_matching_document) { create(:document, name: 'other_name', status: 'processing') }
+    context 'when Filter#column is different from filter_key' do
+      let(:filter) { Kiroshi::Filter.new(:user_name, match: :exact, column: :full_name) }
+      let(:filter_value) { 'John Doe' }
 
-      it 'filters by the configured attribute only returning the matched' do
+      let!(:matching_document) { create(:document, full_name: 'John Doe') }
+      let!(:non_matching_document) { create(:document, full_name: 'Jane Smith') }
+
+      it 'filters using the column name instead of filter_key' do
         expect(runner.apply).to include(matching_document)
       end
 
       it 'does not return non-matching records' do
         expect(runner.apply).not_to include(non_matching_document)
       end
+
+      it 'generates correct SQL using the column name' do
+        expected_sql = "SELECT \"documents\".* FROM \"documents\" WHERE \"documents\".\"full_name\" = 'John Doe'"
+        expect(runner.apply.to_sql).to eq(expected_sql)
+      end
+
+      context 'with LIKE match' do
+        let(:filter) { Kiroshi::Filter.new(:user_name, match: :like, column: :full_name) }
+        let(:filter_value) { 'John' }
+
+        let!(:partial_match) { create(:document, full_name: 'Johnny Smith') }
+
+        it 'performs LIKE filtering using the column name' do
+          expect(runner.apply).to include(matching_document)
+        end
+
+        it 'includes partial matches using the column name' do
+          expect(runner.apply).to include(partial_match)
+        end
+
+        it 'generates correct LIKE SQL using the column name' do
+          expected_sql = "SELECT \"documents\".* FROM \"documents\" WHERE (\"documents\".\"full_name\" LIKE '%John%')"
+          expect(runner.apply.to_sql).to eq(expected_sql)
+        end
+      end
     end
   end
 end

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,103 @@
+# 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
+
+    context 'when column is different from filter_key' do
+      let(:filters) { { user_name: 'John Doe' } }
+
+      context 'with exact match' do
+        it do
+          expect { filters_class.filter_by :user_name, column: :full_name }
+            .to change { filter_instance.apply(scope) }
+            .from(scope).to(scope.where(full_name: 'John Doe'))
+        end
+      end
+
+      context 'with like match' do
+        let(:filters) { { user_name: 'John' } }
+
+        it do
+          expect { filters_class.filter_by :user_name, match: :like, column: :full_name }
+            .to change { filter_instance.apply(scope) }
+            .from(scope).to(scope.where('"documents"."full_name" LIKE ?', '%John%'))
+        end
+      end
+
+      context 'with table qualification and different column' do
+        let(:scope) { Document.joins(:tags) }
+        let(:filters) { { tag_identifier: 'ruby' } }
+
+        it do
+          expect { filters_class.filter_by :tag_identifier, table: :tags, column: :name }
+            .to change { filter_instance.apply(scope) }
+            .from(scope).to(scope.where(tags: { name: 'ruby' }))
+        end
+      end
+
+      context 'with like match, table qualification and different column' do
+        let(:scope) { Document.joins(:tags) }
+        let(:filters) { { tag_identifier: 'rub' } }
+
+        it do
+          expect { filters_class.filter_by :tag_identifier, match: :like, table: :tags, column: :name }
+            .to change { filter_instance.apply(scope) }
+            .from(scope).to(scope.where('"tags"."name" LIKE ?', '%rub%'))
+        end
+      end
+    end
+  end
+end