bharat_filter_engine 0.1.2 → 0.2.0pre

data/spec/rule_normalizer_spec.rb

@@ -1,52 +1,201 @@
-require "spec_helper"
+# frozen_string_literal: true
+
+require 'spec_helper'
 
 RSpec.describe BharatFilterEngine::RuleNormalizer do
+  it 'keeps modern configuration unchanged' do
+    rule = {
+      type: :single,
+      filter_type: :string,
+      dbcolumn: :stage
+    }
 
-    it "keeps modern configuration unchanged" do
+    expect(
+      described_class.call(rule)
+    ).to eq(rule)
+  end
 
-        rule = {
-        type: :single,
-        filter_type: :string,
+  it 'supports legacy configuration' do
+    result =
+      described_class.call(
+        type: :string,
         dbcolumn: :stage
-        }
+      )
+
+    expect(
+      result[:type]
+    ).to eq(:single)
+
+    expect(
+      result[:filter_type]
+    ).to eq(:string)
+  end
+
+  it 'returns nil for nil rule' do
+    expect(
+      described_class.call(nil)
+    ).to be_nil
+  end
+
+  it 'symbolizes rule keys' do
+    result = described_class.call(
+      'type' => :single,
+      'filter_type' => :string,
+      'dbcolumn' => :stage
+    )
+
+    expect(result[:type]).to eq(:single)
+    expect(result[:filter_type]).to eq(:string)
+    expect(result[:dbcolumn]).to eq(:stage)
+  end
 
-        expect(
-        described_class.call(rule)
-        ).to eq(rule)
+  describe 'validation' do
+    it 'raises for an unknown filter_type' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :not_a_real_type,
+          dbcolumn: :stage
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
     end
 
-    it "supports legacy configuration" do
+    it 'raises when a nested rule is missing association' do
+      expect do
+        described_class.call(
+          type: :nested,
+          filter_type: :string,
+          dbcolumn: :source
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+    end
 
-        result =
+    it 'raises when a search rule is missing dbcolumns' do
+      expect do
         described_class.call(
-            type: :string,
-            dbcolumn: :stage
+          type: :single,
+          filter_type: :search
         )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+    end
 
-        expect(
-        result[:type]
-        ).to eq(:single)
+    it 'raises when a search rule has an empty dbcolumns array' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :search,
+          dbcolumns: []
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+    end
 
-        expect(
-        result[:filter_type]
-        ).to eq(:string)
+    it 'raises when a non-search rule is missing dbcolumn' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :string
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
     end
 
-    it "returns nil for nil rule" do
-        expect(
-            described_class.call(nil)
-        ).to be_nil
+    it 'raises for an unknown range_type' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :integer,
+          dbcolumn: :amount,
+          range_type: :nonsense
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
     end
 
-    it "symbolizes rule keys" do
-        result = described_class.call(
-            "type" => :single,
-            "filter_type" => :string,
-            "dbcolumn" => :stage
+    it 'raises when range_type is used on a non-numeric filter_type' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :string,
+          dbcolumn: :stage,
+          range_type: :gte
         )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+    end
 
-        expect(result[:type]).to eq(:single)
-        expect(result[:filter_type]).to eq(:string)
-        expect(result[:dbcolumn]).to eq(:stage)
+    it 'allows range_type: :between on integer/float filters' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :integer,
+          dbcolumn: :amount,
+          range_type: :between
+        )
+      end.not_to raise_error
+    end
+
+    it 'raises when negate is combined with range_type' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :integer,
+          dbcolumn: :amount,
+          range_type: :gte,
+          negate: true
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+    end
+
+    it 'raises when negate is combined with a daterange filter' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :daterange,
+          dbcolumn: :actual_sale_date,
+          negate: true
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+    end
+
+    it 'raises when negate is combined with a search filter' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :search,
+          dbcolumns: [:stage],
+          negate: true
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+    end
+
+    it 'raises when negate is combined with a presence filter' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :presence,
+          dbcolumn: :stage,
+          negate: true
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+    end
+
+    it 'allows negate on a plain string/array/boolean/exact-numeric filter' do
+      expect do
+        described_class.call(
+          type: :single,
+          filter_type: :string,
+          dbcolumn: :stage,
+          negate: true
+        )
+      end.not_to raise_error
+    end
+
+    it 'raises when filter_type: :search is combined with type: :nested' do
+      expect do
+        described_class.call(
+          type: :nested,
+          filter_type: :search,
+          association: :lead,
+          dbcolumns: [:source]
+        )
+      end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
     end
-end
+  end
+end

data/spec/search_builder_spec.rb

@@ -1,79 +1,78 @@
-require "spec_helper"
+# frozen_string_literal: true
 
-RSpec.describe BharatFilterEngine::SearchBuilder do
+require 'spec_helper'
 
+RSpec.describe BharatFilterEngine::SearchBuilder do
   let!(:client) do
     Client.create!(
-      name: "John Doe",
-      email: "john@example.com"
+      name: 'John Doe',
+      email: 'john@example.com'
     )
   end
 
   let!(:lead) do
     Lead.create!(
-      source: "google",
+      source: 'google',
       client: client
     )
   end
 
   let!(:sale) do
     Sale.create!(
-      stage: "qualified",
+      stage: 'qualified',
       lead: lead
     )
   end
 
-  it "supports simple search" do
-
+  it 'supports simple search' do
     result =
       described_class.new(
         scope: Sale.all,
-        allowed_columns: [
-          :stage,
-          :"lead__source"
+        allowed_columns: %i[
+          stage
+          lead__source
         ]
-      ).apply("google")
+      ).apply('google')
 
     expect(result).to contain_exactly(sale)
   end
 
-  it "supports case insensitive search" do
+  it 'supports case insensitive search' do
     result =
       described_class.new(
         scope: Sale.all,
         allowed_columns: [:stage]
-      ).apply("QUAL")
+      ).apply('QUAL')
 
     expect(result).to contain_exactly(sale)
   end
 
-  it "supports nested field search" do
-
+  it 'supports nested field search' do
     result =
       described_class.new(
         scope: Sale.all,
         allowed_columns: [
-          :"lead__client__name"
+          :lead__client__name
         ]
       ).apply(
-        "lead__client__name=John"
+        'lead__client__name=John'
       )
 
     expect(result).to contain_exactly(sale)
   end
 
-  it "supports multi-level association search" do
+  it 'supports multi-level association search' do
     organization = Organization.create!(
-      name: "Acme"
+      name: 'Acme'
     )
 
     client_two = Client.create!(
-      name: "Jane",
+      name: 'Jane',
       organization: organization
     )
 
     lead_two = Lead.create!(
-      source: "referral",
+      source: 'referral',
       client: client_two
     )
 
@@ -85,56 +84,55 @@ RSpec.describe BharatFilterEngine::SearchBuilder do
       described_class.new(
         scope: Sale.all,
         allowed_columns: [
-          :"lead__client__organization__name"
+          :lead__client__organization__name
         ]
       ).apply(
-        "lead__client__organization__name=Acme"
+        'lead__client__organization__name=Acme'
       )
 
     expect(result).to contain_exactly(sale_two)
   end
 
-  it "supports OR search" do
-
+  it 'supports OR search' do
     result =
       described_class.new(
         scope: Sale.all,
-        allowed_columns: [
-          :stage,
-          :"lead__source"
+        allowed_columns: %i[
+          stage
+          lead__source
         ]
       ).apply(
-        "stage=qualified|lead__source=google"
+        'stage=qualified|lead__source=google'
       )
 
     expect(result).to contain_exactly(sale)
   end
 
-  it "supports combined AND and OR conditions" do
+  it 'supports combined AND and OR conditions' do
     sale_one = Sale.create!(
-      stage: "qualified",
-      approval_status: "approved"
+      stage: 'qualified',
+      approval_status: 'approved'
     )
 
     sale_two = Sale.create!(
-      stage: "qualified",
-      approval_status: "pending"
+      stage: 'qualified',
+      approval_status: 'pending'
     )
 
     Sale.create!(
-      stage: "new",
-      approval_status: "approved"
+      stage: 'new',
+      approval_status: 'approved'
     )
 
     result =
       described_class.new(
         scope: Sale.all,
-        allowed_columns: [
-          :stage,
-          :approval_status
+        allowed_columns: %i[
+          stage
+          approval_status
         ]
       ).apply(
-        "stage=qualified&approval_status=approved|approval_status=pending"
+        'stage=qualified&approval_status=approved|approval_status=pending'
       )
 
     expect(result).to contain_exactly(
@@ -143,15 +141,152 @@ RSpec.describe BharatFilterEngine::SearchBuilder do
     )
   end
 
-  it "returns no records when the searched field is not configured" do
+  it 'returns no records when the searched field is not configured' do
+    result =
+      described_class.new(
+        scope: Sale.all,
+        allowed_columns: [:stage]
+      ).apply(
+        'unknown=value'
+      )
+
+    expect(result).to be_empty
+  end
+
+  it 'supports searching the id column as text' do
+    result =
+      described_class.new(
+        scope: Sale.all,
+        allowed_columns: [:id]
+      ).apply(
+        "id=#{sale.id}"
+      )
+
+    expect(result).to contain_exactly(sale)
+  end
+
+  it "handles a value that itself contains an '=' sign" do
+    sale_with_url = Sale.create!(
+      stage: 'https://example.com?x=1'
+    )
+
+    result =
+      described_class.new(
+        scope: Sale.all,
+        allowed_columns: [:stage]
+      ).apply(
+        'stage=https://example.com?x=1'
+      )
+
+    expect(result).to contain_exactly(sale_with_url)
+  end
+
+  it 'skips a whitespace-only expression value' do
     result =
       described_class.new(
         scope: Sale.all,
         allowed_columns: [:stage]
       ).apply(
-        "unknown=value"
+        'stage=   '
       )
 
+    # every expression in the (only) AND group is blank/skipped, so
+    # the group can never match anything
     expect(result).to be_empty
   end
+
+  it 'returns the scope unchanged when allowed_columns is empty' do
+    result =
+      described_class.new(
+        scope: Sale.all,
+        allowed_columns: []
+      ).apply('anything')
+
+    expect(result).to contain_exactly(sale)
+  end
+
+  it 'raises when none of the allowed_columns can be resolved' do
+    expect do
+      described_class.new(
+        scope: Sale.all,
+        allowed_columns: %i[
+          totally_not_a_column
+          also__not__real
+        ]
+      )
+    end.to raise_error(BharatFilterEngine::InvalidConfigurationError)
+  end
+
+  it 'does not raise when only some allowed_columns are invalid' do
+    expect do
+      described_class.new(
+        scope: Sale.all,
+        allowed_columns: %i[
+          stage
+          totally_not_a_column
+        ]
+      )
+    end.not_to raise_error
+  end
+
+  it 'reuses a single AssociationResolver across a whole search' do
+    allow(BharatFilterEngine::AssociationResolver)
+      .to receive(:new)
+      .and_call_original
+
+    described_class.new(
+      scope: Sale.all,
+      allowed_columns: %i[
+        lead__source
+        lead__client__name
+      ]
+    ).apply(
+      'lead__source=google&lead__client__name=John'
+    )
+
+    expect(BharatFilterEngine::AssociationResolver)
+      .to have_received(:new)
+      .once
+  end
+
+  describe 'LIKE wildcard escaping' do
+    it 'treats a literal underscore as a literal character, not a wildcard' do
+      match = Sale.create!(stage: 'sale_2026')
+      Sale.create!(stage: 'saleX2026')
+
+      result =
+        described_class.new(
+          scope: Sale.all,
+          allowed_columns: [:stage]
+        ).apply('sale_2026')
+
+      expect(result).to contain_exactly(match)
+    end
+
+    it 'treats a literal percent sign as a literal character, not a wildcard' do
+      match = Sale.create!(stage: '50%off')
+      Sale.create!(stage: '50xoff')
+
+      result =
+        described_class.new(
+          scope: Sale.all,
+          allowed_columns: [:stage]
+        ).apply('50%off')
+
+      expect(result).to contain_exactly(match)
+    end
+
+    it 'escapes wildcards in field-based search too' do
+      match = Sale.create!(stage: 'sale_2026')
+      Sale.create!(stage: 'saleX2026')
+
+      result =
+        described_class.new(
+          scope: Sale.all,
+          allowed_columns: [:stage]
+        ).apply('stage=sale_2026')
+
+      expect(result).to contain_exactly(match)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require "bundler/setup"
-require "active_record"
-require "database_cleaner/active_record"
-require "bharat_filter_engine"
-require "sqlite3"
+require 'bundler/setup'
+require 'active_record'
+require 'database_cleaner/active_record'
+require 'bharat_filter_engine'
+require 'sqlite3'
 
 ActiveRecord::Base.establish_connection(
-  adapter: "sqlite3",
-  database: ":memory:"
+  adapter: 'sqlite3',
+  database: ':memory:'
 )
 
 ActiveRecord::Schema.define do
@@ -41,29 +41,24 @@ ActiveRecord::Schema.define do
   end
 end
 
-
 class Organization < ActiveRecord::Base
   has_many :clients
 end
 
-
 class Client < ActiveRecord::Base
   belongs_to :organization
   has_many :leads
 end
 
-
 class Lead < ActiveRecord::Base
   belongs_to :client
   has_many :sales
 end
 
-
 class Sale < ActiveRecord::Base
   belongs_to :lead
 end
 
-
 RSpec.configure do |config|
   config.before(:suite) do
     DatabaseCleaner.clean_with(:truncation)

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: bharat_filter_engine
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0pre
 platform: ruby
 authors:
 - Jayesh Rathore
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-03 00:00:00.000000000 Z
+date: 2026-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.1'
 - !ruby/object:Gem::Dependency
-  name: activemodel
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,9 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.1'
 description: Configurable Rails ActiveRecord filtering engine supporting string, array,
-  boolean, numeric, date-range, nested association and AND/OR search filters.
+  boolean, numeric (with gte/lte/between ranges), date-range, presence, negate/exclude,
+  nested association, and AND/OR search filters, plus dynamic filter-value lookups
+  for dropdowns/autocomplete.
 email:
 - jayeshrathore7024@gmail.com
 executables: []
@@ -83,6 +85,7 @@ homepage: https://github.com/jayesh70240/bharat-filter-engine
 licenses:
 - MIT
 metadata:
+  homepage_uri: https://github.com/jayesh70240/bharat-filter-engine
   source_code_uri: https://github.com/jayesh70240/bharat-filter-engine
   changelog_uri: https://github.com/jayesh70240/bharat-filter-engine/blob/main/CHANGELOG.md
   bug_tracker_uri: https://github.com/jayesh70240/bharat-filter-engine/issues