kiroshi 0.1.0 → 0.1.1

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

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+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)        { 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') }
+    let!(:non_matching_document) { create(:document, name: 'other_document') }
+
+    let(:expected_sql) do
+      <<~SQL.squish
+        SELECT "documents".* FROM "documents" WHERE (documents.name LIKE '%test%')
+      SQL
+    end
+
+    it 'returns records that partially match the filter value' do
+      expect(query.apply).to include(matching_document)
+    end
+
+    it 'returns multiple records that contain the filter value' do
+      expect(query.apply).to include(another_match)
+    end
+
+    it 'does not return records that do not contain the filter value' do
+      expect(query.apply).not_to include(non_matching_document)
+    end
+
+    it 'generates correct SQL with LIKE operation' do
+      expect(query.apply.to_sql).to eq(expected_sql)
+    end
+
+    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') }
+      let!(:draft_document)         { create(:document, status: 'draft') }
+
+      let(:expected_sql) do
+        <<~SQL.squish
+          SELECT "documents".* FROM "documents" WHERE (documents.status LIKE '%pub%')
+        SQL
+      end
+
+      it 'returns documents with partial status match' do
+        expect(query.apply).to include(published_document)
+      end
+
+      it 'returns documents with partial match in different positions' do
+        expect(query.apply).to include(republished_document)
+      end
+
+      it 'does not return documents without partial status match' do
+        expect(query.apply).not_to include(draft_document)
+      end
+
+      it 'generates correct SQL for status filtering' do
+        expect(query.apply.to_sql).to eq(expected_sql)
+      end
+    end
+
+    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') }
+      let!(:different_version) { create(:document, version: '3.0.0') }
+
+      let(:expected_sql) do
+        <<~SQL.squish
+          SELECT "documents".* FROM "documents" WHERE (documents.version LIKE '%1.2%')
+        SQL
+      end
+
+      it 'returns documents with partial numeric match' do
+        expect(query.apply).to include(version_match)
+      end
+
+      it 'returns documents with partial match in different positions' do
+        expect(query.apply).to include(another_version)
+      end
+
+      it 'does not return documents without partial numeric match' do
+        expect(query.apply).not_to include(different_version)
+      end
+
+      it 'generates correct SQL for numeric string filtering' do
+        expect(query.apply.to_sql).to eq(expected_sql)
+      end
+    end
+
+    context 'when no records match' do
+      let(:filter_value) { 'nonexistent' }
+
+      let(:expected_sql) do
+        <<~SQL.squish
+          SELECT "documents".* FROM "documents" WHERE (documents.name LIKE '%nonexistent%')
+        SQL
+      end
+
+      it 'returns empty relation' do
+        expect(query.apply).to be_empty
+      end
+
+      it 'still generates valid SQL' do
+        expect(query.apply.to_sql).to eq(expected_sql)
+      end
+    end
+
+    context 'with case sensitivity' do
+      let(:filter_value)        { 'Test' }
+      let!(:lowercase_document) { create(:document, name: 'test_document') }
+      let!(:uppercase_document) { create(:document, name: 'TEST_FILE') }
+      let!(:mixedcase_document) { create(:document, name: 'Test_Document') }
+      let!(:no_match_document)  { create(:document, name: 'example') }
+
+      it 'includes documents with exact case match' do
+        expect(query.apply).to include(mixedcase_document)
+      end
+
+      it 'includes documents with lowercase match' do
+        expect(query.apply).to include(lowercase_document)
+      end
+
+      it 'includes documents with uppercase match' do
+        expect(query.apply).to include(uppercase_document)
+      end
+
+      it 'excludes documents without any case match' do
+        expect(query.apply).not_to include(no_match_document)
+      end
+    end
+
+    context 'with special characters in filter value' do
+      let(:filter_value) { 'user@' }
+      let!(:email_document)         { create(:document, name: 'user@example.com') }
+      let!(:partial_email_document) { create(:document, name: 'admin_user@test.org') }
+      let!(:no_match_document)      { create(:document, name: 'username') }
+
+      it 'includes documents with special character match' do
+        expect(query.apply).to include(email_document)
+      end
+
+      it 'includes documents with partial special character match' do
+        expect(query.apply).to include(partial_email_document)
+      end
+
+      it 'excludes documents without special character match' do
+        expect(query.apply).not_to include(no_match_document)
+      end
+    end
+
+    context 'with single character filter' do
+      let(:filter_value)       { 'a' }
+      let!(:start_match)       { create(:document, name: 'apple') }
+      let!(:middle_match)      { create(:document, name: 'banana') }
+      let!(:end_match)         { create(:document, name: 'extra') }
+      let!(:no_match_document) { create(:document, name: 'test') }
+
+      it 'includes documents with character at start' do
+        expect(query.apply).to include(start_match)
+      end
+
+      it 'includes documents with character in middle' do
+        expect(query.apply).to include(middle_match)
+      end
+
+      it 'includes documents with character at end' do
+        expect(query.apply).to include(end_match)
+      end
+
+      it 'excludes documents without the character' do
+        expect(query.apply).not_to include(no_match_document)
+      end
+    end
+
+    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') }
+
+      let!(:document_with_ruby_tag) { create(:document, name: 'My Document') }
+      let!(:document_with_rails_tag) { create(:document, name: 'Rails Guide') }
+      let!(:document_without_tag)    { create(:document, name: 'Other Document') }
+
+      before do
+        Tag.find_or_create_by(name: 'programming')
+        document_with_ruby_tag.tags << [first_tag]
+        document_with_rails_tag.tags << [second_tag]
+      end
+
+      context 'when filtering by tags table' do
+        let(:filter) { Kiroshi::Filter.new(:name, match: :like, table: :tags) }
+
+        it 'returns documents with tags that partially match the filter value' do
+          expect(query.apply).to include(document_with_ruby_tag)
+        end
+
+        it 'returns documents with tags that contain the filter value' do
+          expect(query.apply).to include(document_with_rails_tag)
+        end
+
+        it 'does not return documents without matching tags' do
+          expect(query.apply).not_to include(document_without_tag)
+        end
+
+        it 'generates SQL with tags table qualification' do
+          result_sql = query.apply.to_sql
+          expect(result_sql).to include('tags.name LIKE')
+        end
+
+        it 'generates SQL with correct LIKE pattern for tag name' do
+          result_sql = query.apply.to_sql
+          expect(result_sql).to include("'%ruby%'")
+        end
+      end
+
+      context 'when filtering by documents table explicitly' do
+        let(:filter)       { Kiroshi::Filter.new(:name, match: :like, table: :documents) }
+        let(:filter_value) { 'Guide' }
+
+        it 'returns documents that partially match the filter value in document name' do
+          expect(query.apply).to include(document_with_rails_tag)
+        end
+
+        it 'does not return documents that do not match document name' do
+          expect(query.apply).not_to include(document_with_ruby_tag)
+        end
+
+        it 'does not return documents without matching document name' do
+          expect(query.apply).not_to include(document_without_tag)
+        end
+
+        it 'generates SQL with documents table qualification' do
+          result_sql = query.apply.to_sql
+          expect(result_sql).to include('documents.name LIKE')
+        end
+
+        it 'generates SQL with correct LIKE pattern for document name' do
+          result_sql = query.apply.to_sql
+          expect(result_sql).to include("'%Guide%'")
+        end
+      end
+
+      context 'when table is specified as string' do
+        let(:filter) { Kiroshi::Filter.new(:name, match: :like, table: 'tags') }
+
+        it 'works the same as with symbol table name' do
+          expect(query.apply).to include(document_with_ruby_tag)
+        end
+
+        it 'generates SQL with string table qualification' do
+          result_sql = query.apply.to_sql
+          expect(result_sql).to include('tags.name LIKE')
+        end
+      end
+    end
+  end
+end

data/spec/lib/kiroshi/filter_query_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kiroshi::FilterQuery, type: :model do
+  describe '.for' do
+    context 'when match is :exact' do
+      it 'returns the Exact class' do
+        expect(described_class.for(:exact)).to eq(Kiroshi::FilterQuery::Exact)
+      end
+    end
+
+    context 'when match is :like' do
+      it 'returns the Like class' do
+        expect(described_class.for(:like)).to eq(Kiroshi::FilterQuery::Like)
+      end
+    end
+
+    context 'when match is an unsupported type' do
+      it 'raises ArgumentError for unsupported match type' do
+        expect { described_class.for(:invalid) }.to raise_error(
+          ArgumentError, 'Unsupported match type: invalid'
+        )
+      end
+
+      it 'raises ArgumentError for nil match type' do
+        expect { described_class.for(nil) }.to raise_error(
+          ArgumentError, 'Unsupported match type: '
+        )
+      end
+
+      it 'raises ArgumentError for string match type' do
+        expect { described_class.for('exact') }.to raise_error(
+          ArgumentError, 'Unsupported match type: exact'
+        )
+      end
+    end
+  end
+end

data/spec/lib/kiroshi/filter_runner_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kiroshi::FilterRunner, type: :model do
+  describe '#apply' do
+    subject(:runner) { described_class.new(filter: filter, scope: scope, filters: filters) }
+
+    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 filter match is :exact' do
+      let(:filter) { Kiroshi::Filter.new(:name, match: :exact) }
+
+      it 'returns exact matches' 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
+    end
+
+    context 'when filter match is :like' do
+      let(:filter)                 { Kiroshi::Filter.new(:name, match: :like) }
+      let(:filter_value)           { 'test' }
+      let!(:matching_document)     { create(:document, name: 'test_document') }
+      let!(:non_matching_document) { create(:document, name: 'other_value') }
+
+      it 'returns partial matches' 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 with table name prefix' do
+        expected_sql = "SELECT \"documents\".* FROM \"documents\" WHERE (documents.name LIKE '%test%')"
+        expect(runner.apply.to_sql).to eq(expected_sql)
+      end
+    end
+
+    context 'when filter match is not specified (default)' do
+      let(:filter) { Kiroshi::Filter.new(:name) }
+
+      it 'defaults to exact match returning only exact matches' do
+        expect(runner.apply).to include(matching_document)
+      end
+
+      it 'defaults to exact match not returning non-matching records' do
+        expect(runner.apply).not_to include(non_matching_document)
+      end
+    end
+
+    context 'when filter value is not present' do
+      let(:filter)  { Kiroshi::Filter.new(:name) }
+      let(:filters) { { name: nil } }
+
+      it 'returns the original scope unchanged' do
+        expect(runner.apply).to eq(scope)
+      end
+    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) { {} }
+
+      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' } }
+      let!(:matching_document)     { create(:document, name: 'test_name', status: 'finished') }
+      let!(:non_matching_document) { create(:document, name: 'other_name', status: 'processing') }
+
+      it 'filters by the configured attribute only returning the matched' 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
+    end
+  end
+end

data/spec/lib/kiroshi/filters_spec.rb

@@ -90,5 +90,68 @@ 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.instance_variable_set(:@filter_configs, [])
+          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
   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.1.1
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-17 00:00:00.000000000 Z
+date: 2025-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -65,19 +65,29 @@ 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/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_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: []