bharat_filter_engine 0.1.1

data/lib/bharat_filter_engine/search_builder.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module BharatFilterEngine
+  class SearchBuilder
+    def initialize(scope:, allowed_columns:)
+      @scope = scope
+      @allowed_columns =
+        Array(allowed_columns).map(&:to_s)
+    end
+
+    def apply(value)
+      return @scope if value.blank?
+
+      search = value.to_s.strip
+
+      if search.include?("=")
+        field_based_search(search)
+      else
+        simple_search(search)
+      end
+    end
+
+    private
+
+    def simple_search(search)
+      query = "%#{search}%"
+      conditions = []
+
+      @allowed_columns.each do |dbcolumn|
+        next unless valid_field?(dbcolumn)
+
+        if dbcolumn.include?("__")
+          @scope, condition =
+            nested_condition(
+              @scope,
+              dbcolumn,
+              query
+            )
+
+          conditions << condition if condition
+        else
+          table = @scope.klass.arel_table
+
+          conditions << table[dbcolumn].matches(query)
+        end
+      end
+
+      return @scope if conditions.empty?
+
+      @scope.where(
+        conditions.reduce { |left, right| left.or(right) }
+      )
+    end
+
+    # field=value pairs, "&" = AND, "|" = OR within an AND group.
+    #
+    # If an AND group ends up with no valid conditions (e.g. every
+    # field in it is unknown/blank), that group can never be satisfied
+    # -- it must NOT be silently dropped, otherwise the whole search
+    # is skipped and unrelated records leak through unfiltered.
+    def field_based_search(search)
+      and_conditions =
+        search.split("&").map do |and_group|
+          or_conditions =
+            and_group.split("|").filter_map do |expression|
+              field, search_value =
+                expression.split("=", 2)
+
+              next if field.blank?
+              next if search_value.blank?
+              next unless valid_field?(field)
+
+              query = "%#{search_value.strip}%"
+
+              if field.include?("__")
+                @scope, condition =
+                  nested_condition(
+                    @scope,
+                    field,
+                    query
+                  )
+
+                condition
+              elsif field == "id"
+                quoted_column =
+                  @scope.klass
+                        .connection
+                        .quote_column_name(field)
+
+                Arel.sql(
+                  "#{@scope.klass.quoted_table_name}.#{quoted_column}::text"
+                ).matches(query)
+              else
+                @scope.klass.arel_table[field].matches(query)
+              end
+            end
+
+          # Every expression in this AND group was invalid/unmatchable,
+          # so the whole search can never match anything.
+          return @scope.none if or_conditions.empty?
+
+          or_conditions.reduce { |left, right| left.or(right) }
+        end
+
+      return @scope if and_conditions.empty?
+
+      @scope.where(
+        and_conditions.reduce { |left, right| left.and(right) }
+      )
+    end
+
+    def valid_field?(field)
+      if field.include?("__")
+        !resolver.resolve_column(field).nil?
+      else
+        @scope.klass.column_names.include?(field)
+      end
+    end
+
+    def nested_condition(scope, field, query)
+      result = resolver.resolve_column(field)
+
+      return [scope, nil] unless result
+
+      joined_scope =
+        resolver.join(
+          scope,
+          result[:associations]
+        )
+
+      condition =
+        result[:klass]
+          .arel_table[result[:column]]
+          .matches(query)
+
+      [joined_scope, condition]
+    end
+
+    # AssociationResolver only needs @scope.klass (which never changes
+    # across joins), so a single instance can be reused for the whole
+    # search instead of being rebuilt every time the scope is updated.
+    def resolver
+      @resolver ||= AssociationResolver.new(@scope)
+    end
+  end
+end

data/lib/bharat_filter_engine/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BharatFilterEngine
+  VERSION = "0.1.1"
+end

data/lib/bharat_filter_engine.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_model"
+require "active_support"
+require "json"
+
+require_relative "bharat_filter_engine/version"
+require_relative "bharat_filter_engine/errors"
+require_relative "bharat_filter_engine/association_resolver"
+require_relative "bharat_filter_engine/rule_normalizer"
+require_relative "bharat_filter_engine/search_builder"
+require_relative "bharat_filter_engine/dynamic_filter_values"
+require_relative "bharat_filter_engine/engine"
+
+module BharatFilterEngine
+  class << self
+    def apply(scope:, config:, params:)
+      Engine.apply(
+        scope: scope,
+        config: config,
+        params: params
+      )
+    end
+
+    def filter_values(scope:, config:, params:)
+      Engine.filter_values(
+        scope: scope,
+        config: config,
+        params: params
+      )
+    end
+  end
+end

data/spec/association_resolver_spec.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe BharatFilterEngine::AssociationResolver do
+
+  let(:resolver) do
+    described_class.new(
+      Sale.all
+    )
+  end
+
+  describe "#resolve" do
+
+    it "resolves a direct association" do
+      result = resolver.resolve("lead")
+
+      expect(result[:associations]).to eq(
+        [:lead]
+      )
+
+      expect(result[:klass]).to eq(
+        Lead
+      )
+    end
+
+    it "resolves nested associations" do
+      result = resolver.resolve(
+        "lead__client"
+      )
+
+      expect(result[:associations]).to eq(
+        [:lead, :client]
+      )
+
+      expect(result[:klass]).to eq(
+        Client
+      )
+    end
+
+    it "resolves multi-level associations" do
+      result = resolver.resolve(
+        "lead__client__organization"
+      )
+
+      expect(result[:associations]).to eq(
+        [
+          :lead,
+          :client,
+          :organization
+        ]
+      )
+
+      expect(result[:klass]).to eq(
+        Organization
+      )
+    end
+
+    it "returns nil for invalid association" do
+      result = resolver.resolve(
+        "unknown"
+      )
+
+      expect(result).to be_nil
+    end
+  end
+
+  describe "#resolve_column" do
+
+    it "resolves direct columns" do
+      result =
+        resolver.resolve_column(
+          "stage"
+        )
+
+      expect(result[:column]).to eq(
+        "stage"
+      )
+
+      expect(result[:associations]).to eq([])
+    end
+
+    it "resolves nested columns" do
+      result =
+        resolver.resolve_column(
+          "lead__source"
+        )
+
+      expect(result[:column]).to eq(
+        "source"
+      )
+
+      expect(result[:associations]).to eq(
+        [:lead]
+      )
+    end
+
+    it "resolves multi-level columns" do
+      result =
+        resolver.resolve_column(
+          "lead__client__name"
+        )
+
+      expect(result[:column]).to eq(
+        "name"
+      )
+
+      expect(result[:associations]).to eq(
+        [:lead, :client]
+      )
+
+      expect(result[:klass]).to eq(
+        Client
+      )
+    end
+
+    it "returns nil for invalid column" do
+      result =
+        resolver.resolve_column(
+          "lead__invalid"
+        )
+
+      expect(result).to be_nil
+    end
+  end
+
+  describe "#join" do
+
+    it "joins one association" do
+      scope =
+        resolver.join(
+          Sale.all,
+          [:lead]
+        )
+
+      expect(
+        scope.to_sql
+      ).to include(
+        "JOIN"
+      )
+    end
+
+    it "joins nested associations" do
+      scope =
+        resolver.join(
+          Sale.all,
+          [
+            :lead,
+            :client
+          ]
+        )
+
+      expect(
+        scope.to_sql
+      ).to include(
+        "JOIN"
+      )
+    end
+  end
+end

data/spec/dynamic_filter_values_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+
+RSpec.describe BharatFilterEngine::DynamicFilterValues do
+
+  let!(:client_one) do
+    Client.create!(
+      name: "John"
+    )
+  end
+
+  let!(:client_two) do
+    Client.create!(
+      name: "Jane"
+    )
+  end
+
+  let!(:lead_one) do
+    Lead.create!(
+      source: "google",
+      client: client_one
+    )
+  end
+
+  let!(:lead_two) do
+    Lead.create!(
+      source: "referral",
+      client: client_two
+    )
+  end
+
+  before do
+    Sale.create!(
+      stage: "qualified",
+      lead: lead_one
+    )
+
+    Sale.create!(
+      stage: "new",
+      lead: lead_two
+    )
+  end
+
+  it "returns direct values" do
+
+    result =
+      described_class.new(
+        scope: Sale.all,
+        field: "stage"
+      ).call
+
+    expect(result).to eq(
+      %w[new qualified]
+    )
+  end
+
+  it "returns nested values" do
+
+    result =
+      described_class.new(
+        scope: Sale.all,
+        field: "lead__source"
+      ).call
+
+    expect(result).to eq(
+      %w[google referral]
+    )
+  end
+
+  it "returns multi-level nested values" do
+
+    result =
+      described_class.new(
+        scope: Sale.all,
+        field: "lead__client__name"
+      ).call
+
+    expect(result).to eq(
+      %w[Jane John]
+    )
+  end
+
+  it "returns nil for invalid field" do
+
+    result =
+      described_class.new(
+        scope: Sale.all,
+        field: "invalid_field"
+      ).call
+
+    expect(result).to be_nil
+  end
+
+  it "returns nil for a valid association with an invalid column" do
+
+    result =
+      described_class.new(
+        scope: Sale.all,
+        field: "lead__something_wrong"
+      ).call
+
+    expect(result).to be_nil
+  end
+
+  it "returns nil for an invalid association" do
+
+    result =
+      described_class.new(
+        scope: Sale.all,
+        field: "something__name"
+      ).call
+
+    expect(result).to be_nil
+  end
+
+  it "does not return blank values" do
+    Sale.create!(stage: "")
+    Sale.create!(stage: nil)
+
+    result =
+      described_class.new(
+        scope: Sale.all,
+        field: "stage"
+      ).call
+
+    expect(result).to eq(
+      %w[new qualified]
+    )
+  end
+
+end