kiroshi 0.1.1 → 0.3.0

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
@@ -91,8 +91,144 @@ RSpec.describe Kiroshi::Filters, type: :model do
       end
     end
 
+    context 'when filters have string keys' do
+      before do
+        filters_class.filter_by :name, match: :like
+        filters_class.filter_by :status
+      end
+
+      context 'with single string key filter' do
+        let(:filters) { { 'name' => 'test' } }
+
+        it 'returns documents matching the string key filter' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not return documents not matching the string key filter' do
+          expect(filter_instance.apply(scope)).not_to include(other_document)
+        end
+
+        it 'generates SQL with LIKE operation for string key' do
+          expect(filter_instance.apply(scope).to_sql).to include('LIKE')
+        end
+      end
+
+      context 'with multiple string key filters' do
+        let(:filters) { { 'name' => 'test', 'status' => 'finished' } }
+
+        it 'returns documents matching all string key filters' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not return documents not matching all string key filters' do
+          expect(filter_instance.apply(scope)).not_to include(other_document)
+        end
+      end
+
+      context 'with mixed string and symbol keys' do
+        let(:filters) { { 'name' => 'test', status: 'finished' } }
+
+        it 'returns documents matching both string and symbol key filters' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not return documents not matching all mixed key filters' do
+          expect(filter_instance.apply(scope)).not_to include(other_document)
+        end
+
+        it 'treats string and symbol keys equivalently' do
+          string_result = filters_class.new({ 'name' => 'test', 'status' => 'finished' }).apply(scope)
+          symbol_result = filters_class.new({ name: 'test', status: 'finished' }).apply(scope)
+
+          expect(string_result.to_sql).to eq(symbol_result.to_sql)
+        end
+      end
+    end
+
+    context 'when filters is an instance of ActionController::Parameters' do
+      before do
+        filters_class.filter_by :name, match: :like
+        filters_class.filter_by :status
+      end
+
+      context 'with permitted parameters' do
+        let(:filters) do
+          ActionController::Parameters.new(
+            name: 'test',
+            status: 'finished',
+            unauthorized_param: 'ignored'
+          )
+        end
+
+        it 'returns documents matching the permitted parameters' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not return documents not matching the permitted parameters' do
+          expect(filter_instance.apply(scope)).not_to include(other_document)
+        end
+
+        it 'generates SQL with LIKE operation for ActionController::Parameters' do
+          expect(filter_instance.apply(scope).to_sql).to include('LIKE')
+        end
+
+        it 'generates SQL with exact match for status parameter' do
+          expect(filter_instance.apply(scope).to_sql).to include("'finished'")
+        end
+      end
+
+      context 'with unpermitted parameters' do
+        let(:filters) do
+          ActionController::Parameters.new(
+            name: 'test',
+            status: 'finished'
+          )
+        end
+
+        it 'works with unpermitted parameters' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not return documents not matching the parameters' do
+          expect(filter_instance.apply(scope)).not_to include(other_document)
+        end
+      end
+
+      context 'with string keys in ActionController::Parameters' do
+        let(:filters) do
+          ActionController::Parameters.new(
+            'name' => 'test',
+            'status' => 'finished'
+          )
+        end
+
+        it 'returns documents matching the string key parameters' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'does not return documents not matching the string key parameters' do
+          expect(filter_instance.apply(scope)).not_to include(other_document)
+        end
+
+        it 'treats ActionController::Parameters with string keys same as regular hash' do
+          ac_params_result = filter_instance.apply(scope)
+          hash_result = filters_class.new({ 'name' => 'test', 'status' => 'finished' }).apply(scope)
+
+          expect(ac_params_result.to_sql).to eq(hash_result.to_sql)
+        end
+      end
+
+      context 'with empty ActionController::Parameters' do
+        let(:filters) { ActionController::Parameters.new({}) }
+
+        it 'returns the original scope unchanged' do
+          expect(filter_instance.apply(scope)).to eq(scope)
+        end
+      end
+    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 +264,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
 
@@ -144,7 +279,7 @@ RSpec.describe Kiroshi::Filters, type: :model do
 
         it 'generates SQL with table-qualified LIKE operation' do
           result = filter_instance.apply(scope)
-          expect(result.to_sql).to include('documents.name LIKE')
+          expect(result.to_sql).to include('"documents"."name" LIKE')
         end
 
         it 'generates SQL with correct LIKE pattern' do
@@ -153,5 +288,176 @@ RSpec.describe Kiroshi::Filters, type: :model do
         end
       end
     end
+
+    context 'when specifying a different column' do
+      let(:scope)   { Document.joins(:tags) }
+      let(:filters) { { tag_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 :tag_name, table: :tags, column: :name
+
+        document.tags << [ruby_tag]
+        other_document.tags << [js_tag]
+      end
+
+      it 'filters by the specified column name instead of filter key' do
+        expect(filter_instance.apply(scope)).to include(document)
+      end
+
+      it 'does not return documents not matching the column filter' do
+        expect(filter_instance.apply(scope)).not_to include(other_document)
+      end
+
+      it 'generates SQL that filters by tags.name using the column parameter' do
+        expect(filter_instance.apply(scope).to_sql).to include('"tags"."name"')
+      end
+
+      it 'generates SQL that includes the filter value' do
+        expect(filter_instance.apply(scope).to_sql).to include("'ruby'")
+      end
+
+      it 'does not use the filter key name in the SQL' do
+        # The filter key is :tag_name but column is :name, so SQL should use 'name' not 'tag_name'
+        expect(filter_instance.apply(scope).to_sql).not_to include('tag_name')
+      end
+
+      context 'with LIKE matching' do
+        let(:filters) { { tag_name: 'rub' } }
+
+        before do
+          filters_class.filter_by :tag_name, table: :tags, column: :name, match: :like
+        end
+
+        it 'applies LIKE matching to the specified column' do
+          expect(filter_instance.apply(scope)).to include(document)
+        end
+
+        it 'generates SQL with LIKE operation on the specified column' do
+          expect(filter_instance.apply(scope).to_sql).to include('"tags"."name" LIKE')
+        end
+
+        it 'generates SQL with correct LIKE pattern' do
+          expect(filter_instance.apply(scope).to_sql).to include("'%rub%'")
+        end
+      end
+
+      context 'with different filter key and column names' do
+        let(:filters) { { user_full_name: 'test' } }
+
+        before do
+          filters_class.filter_by :user_full_name, column: :name, match: :like
+        end
+
+        it 'uses the column name in database queries' do
+          result = filter_instance.apply(Document.all)
+          expect(result.to_sql).to include('"documents"."name"')
+        end
+
+        it 'does not use the filter key in SQL' do
+          result = filter_instance.apply(Document.all)
+          expect(result.to_sql).not_to include('user_full_name')
+        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/spec_helper.rb

@@ -11,6 +11,7 @@ SimpleCov.start 'gem'
 require 'kiroshi'
 require 'pry-nav'
 require 'active_support/all'
+require 'action_controller/metal/strong_parameters'
 require 'factory_bot'
 
 require 'active_record'

data/spec/support/db/schema.rb

@@ -5,6 +5,7 @@ ActiveRecord::Schema.define do
 
   create_table :documents, force: true do |t|
     t.string   :name
+    t.string   :full_name
     t.string   :status
     t.boolean  :active
     t.integer  :priority

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kiroshi
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.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
@@ -46,7 +46,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
+- ".codacy.yml"
 - ".gitignore"
+- ".markdownlint.json"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
@@ -70,6 +72,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 +81,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