kiroshi 0.0.1 → 0.1.1

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/filter_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+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)
+      end
+
+      it 'does not return non-matching records' do
+        expect(filter.apply(scope, filters)).not_to include(non_matching_document)
+      end
+    end
+
+    context 'when match is :like' do
+      subject(:filter) { described_class.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(filter.apply(scope, filters)).to include(matching_document)
+      end
+
+      it 'does not return non-matching records' do
+        expect(filter.apply(scope, filters)).not_to include(non_matching_document)
+      end
+    end
+
+    context 'when match is not specified (default)' 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)
+      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)
+      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)
+      end
+    end
+  end
+end

data/spec/lib/kiroshi/filters_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Kiroshi::Filters, type: :model do
+  describe '#apply' do
+    subject(:filter_instance) { filters_class.new(filters) }
+
+    let(:scope)           { Document.all }
+    let(:filters)         { {} }
+    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
+          expect(filter_instance.apply(scope)).to eq(scope)
+        end
+      end
+
+      context 'when filters are provided' do
+        let(:filters) { { name: 'test_name' } }
+
+        it 'returns the original scope unchanged' do
+          expect(filter_instance.apply(scope)).to eq(scope)
+        end
+      end
+    end
+
+    context 'when one exact filter is configured' do
+      let(:filters) { { name: 'test_name' } }
+
+      before do
+        filters_class.filter_by :name
+      end
+
+      it 'returns documents matching the exact filter' do
+        expect(filter_instance.apply(scope)).to include(document)
+      end
+
+      it 'does not return documents not matching the exact filter' do
+        expect(filter_instance.apply(scope)).not_to include(other_document)
+      end
+    end
+
+    context 'when one like filter is configured' do
+      let(:filters) { { name: 'test' } }
+
+      before do
+        filters_class.filter_by :name, match: :like
+      end
+
+      it 'returns documents matching the like filter' do
+        expect(filter_instance.apply(scope)).to include(document)
+      end
+
+      it 'does not return documents not matching the like filter' do
+        expect(filter_instance.apply(scope)).not_to include(other_document)
+      end
+    end
+
+    context 'when multiple filters are configured' do
+      let(:filters) { { name: 'test', status: 'finished' } }
+
+      before do
+        filters_class.filter_by :name, match: :like
+        filters_class.filter_by :status
+      end
+
+      it 'returns documents matching all 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 filters hash is empty' do
+      before do
+        filters_class.filter_by :name
+        filters_class.filter_by :status
+      end
+
+      let(:filters) { {} }
+
+      it 'returns the original scope unchanged' 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/spec_helper.rb

@@ -10,6 +10,8 @@ SimpleCov.start 'gem'
 
 require 'kiroshi'
 require 'pry-nav'
+require 'active_support/all'
+require 'factory_bot'
 
 require 'active_record'
 ActiveRecord::Base.establish_connection(

data/spec/support/db/schema.rb

@@ -2,4 +2,23 @@
 
 ActiveRecord::Schema.define do
   self.verbose = false
+
+  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/document.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :document, class: '::Document' do
+    sequence(:name) { |n| "Name-#{n}" }
+  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/factory_bot.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+end
+
+FactoryBot.find_definitions

data/spec/support/models/document.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+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.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Darthjee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-08-15 00:00:00.000000000 Z
+date: 2025-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -62,14 +62,32 @@ files:
 - config/yardstick.yml
 - docker-compose.yml
 - kiroshi.gemspec
+- 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: []