bharat_filter_engine 0.1.2 → 0.2.0pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0c1821308815c4d17986f4cfdf2eea0daeae04849d48fe688aa231891bdfb93
-  data.tar.gz: bb1a6ad5176d209fa37af14deb1dabdd756884eaab062db7d65ade69b0c4b3bb
+  metadata.gz: 811680608cacda9f967cd20ce13482ed5cbe637ce21193d6d7b4932266f15556
+  data.tar.gz: 41c8837e9ae4df42f83d5fae6a7907ed00dfb7308f72273dbe23d7e05f55ac03
 SHA512:
-  metadata.gz: 989674d80aeeaa3589f6a59d77a426acdd69886f780425100ddfe995aabf5096d03e80ec7958e51f66941b79e3ca14606b1b5e545afac0eddb3e9d9cbb87f048
-  data.tar.gz: 06d6923226a0b941075d7e7323f4eca428c493f7f22f625ff8d243962dff812eb1992ac0e7eb888e47341f1df1e430523931fac5a55f76b6c6cc360e31aa7c01
+  metadata.gz: c61055a2cb73bd87b4ddb0bc1258515ee78d1f9dbafe51ad1027165de23b054c3a5d07bb3d3b14c6df089c6d6b34f99b565bedae8a5d05eb63f7ff31bedab5e6
+  data.tar.gz: d68e184b788757dcbb8940cb2096ce85859b6a70864457f4977a3b4607316fa7d455e078624ed5f8acc39a78f458331ef4c0bb7b7f455a6d5f4de57dd01176b1

data/Gemfile

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 gemspec
 
-gem "activerecord", ">= 6.1"
-gem "activemodel", ">= 6.1"
-gem "activesupport", ">= 6.1"
+gem 'activemodel', '>= 6.1'
+gem 'activerecord', '>= 6.1'
+gem 'activesupport', '>= 6.1'
 
 group :development, :test do
-  gem "sqlite3"
-  gem "rspec"
-  gem "rake"
+  gem 'rake'
+  gem 'rspec'
+  gem 'rubocop-rails-omakase', require: false
+  gem 'sqlite3'
 end
 
 group :test do
-  gem "database_cleaner-active_record"
-end
+  gem 'database_cleaner-active_record'
+end

data/README.md

@@ -8,7 +8,7 @@ query string) into a filtered `ActiveRecord::Relation` — including
 filters on associated models, free-text search, and dynamically
 populated dropdown values.
 
-[![Gem Version](https://img.shields.io/badge/version-0.1.1-blue)](CHANGELOG.md)
+[![Gem Version](https://img.shields.io/badge/version-0.1.2-blue)](CHANGELOG.md)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 ---

data/Rakefile

@@ -1,6 +1,8 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+task default: :spec

data/lib/bharat_filter_engine/association_resolver.rb

@@ -7,7 +7,7 @@ module BharatFilterEngine
     end
 
     def resolve(path)
-      parts = path.to_s.split("__").map(&:to_sym)
+      parts = path.to_s.split('__').map(&:to_sym)
 
       return nil if parts.empty?
 
@@ -58,13 +58,13 @@ module BharatFilterEngine
       # lead -> client -> name
       # ----------------------------------------
 
-      parts = field.split("__")
+      parts = field.split('__')
 
       column =
         parts.pop
 
       association_path =
-        parts.join("__")
+        parts.join('__')
 
       result =
         resolve(association_path)
@@ -99,4 +99,4 @@ module BharatFilterEngine
         end
     end
   end
-end
+end

data/lib/bharat_filter_engine/dynamic_filter_values.rb

@@ -2,10 +2,14 @@
 
 module BharatFilterEngine
   class DynamicFilterValues
-    def initialize(scope:, model: nil, field:)
+    LIKE_ESCAPE_CHAR = '\\'
+
+    def initialize(scope:, field:, model: nil, term: nil, limit: nil)
       @scope = scope
       @model = model || scope.klass
       @field = field.to_s
+      @term = term.presence
+      @limit = limit.presence&.to_i
     end
 
     def call
@@ -20,20 +24,32 @@ module BharatFilterEngine
           result[:associations]
         )
 
-      column = result[:column]
-      nested = result[:associations].present?
+      arel_column = result[:klass].arel_table[result[:column]]
+
+      scoped =
+        scoped.where(
+          arel_column.not_eq(nil).and(
+            arel_column.not_eq('')
+          )
+        )
+
+      scoped = apply_term(scoped, arel_column) if @term
+
+      scoped = scoped.distinct.order(arel_column)
+      scoped = scoped.limit(@limit) if @limit&.positive?
+
+      scoped.pluck(arel_column)
+    end
 
-      not_condition =
-        nested ? { result[:table_name] => { column => [nil, ""] } } : { column => [nil, ""] }
+    private
 
-      qualified_column =
-        nested ? Arel.sql("#{result[:table_name]}.#{column}") : column
+    def apply_term(scoped, arel_column)
+      escaped =
+        @term.to_s.gsub(/[\\%_]/) { |char| "#{LIKE_ESCAPE_CHAR}#{char}" }
 
-      scoped
-        .where.not(not_condition)
-        .distinct
-        .order(qualified_column)
-        .pluck(qualified_column)
+      scoped.where(
+        arel_column.matches("%#{escaped}%", LIKE_ESCAPE_CHAR)
+      )
     end
   end
 end

data/lib/bharat_filter_engine/engine.rb

@@ -2,9 +2,7 @@
 
 module BharatFilterEngine
   class Engine
-
     class << self
-
       def apply(scope:, config:, params:)
         new(
           scope,
@@ -16,7 +14,7 @@ module BharatFilterEngine
       def filter_values(scope:, config:, params:)
         field =
           params[:filter_field] ||
-          params["filter_field"]
+          params['filter_field']
 
         rule =
           config[field&.to_sym]
@@ -33,25 +31,33 @@ module BharatFilterEngine
             rule[:dbcolumn].to_s
           end
 
+        term =
+          params[:filter_term] ||
+          params['filter_term']
+
+        limit =
+          params[:filter_limit] ||
+          params['filter_limit']
+
         DynamicFilterValues.new(
           scope: scope,
-          field: field_name
+          field: field_name,
+          term: term,
+          limit: limit
         ).call || []
       end
-
     end
 
     def initialize(scope, config = {}, params = {})
-        @scope = scope
-        @config = config || {}
-        @params = normalize_params(params)
+      @scope = scope
+      @config = config || {}
+      @params = normalize_params(params)
     end
 
     def call
       scope = @scope
 
       @config.each do |key, raw_rule|
-
         value =
           @params[key.to_sym]
 
@@ -104,7 +110,13 @@ module BharatFilterEngine
           association
         )
 
-      return scope unless result
+      unless result
+        raise InvalidAssociationError,
+              'BharatFilterEngine: could not resolve association ' \
+              "#{association.inspect} configured for filter " \
+              "#{rule[:dbcolumn].inspect}. Check the `association:` key " \
+              'in your filter config.'
+      end
 
       joined_scope =
         resolver.join(
@@ -126,7 +138,6 @@ module BharatFilterEngine
       value,
       table_name: nil
     )
-
       column =
         rule[:dbcolumn]
 
@@ -137,7 +148,8 @@ module BharatFilterEngine
           scope,
           column,
           value,
-          table_name
+          table_name,
+          negate: rule[:negate]
         )
 
       when :boolean
@@ -145,14 +157,16 @@ module BharatFilterEngine
           scope,
           column,
           value,
-          table_name
+          table_name,
+          negate: rule[:negate]
         )
 
       when :integer
         apply_numeric_filter(
           scope,
           rule,
-          value.to_i,
+          value,
+          :to_i,
           table_name: table_name
         )
 
@@ -160,7 +174,8 @@ module BharatFilterEngine
         apply_numeric_filter(
           scope,
           rule,
-          value.to_f,
+          value,
+          :to_f,
           table_name: table_name
         )
 
@@ -169,7 +184,8 @@ module BharatFilterEngine
           scope,
           column,
           value,
-          table_name
+          table_name,
+          negate: rule[:negate]
         )
 
       when :daterange
@@ -180,6 +196,14 @@ module BharatFilterEngine
           table_name: table_name
         )
 
+      when :presence
+        apply_presence_filter(
+          scope,
+          column,
+          value,
+          table_name
+        )
+
       when :search
         SearchBuilder.new(
           scope: scope,
@@ -195,14 +219,15 @@ module BharatFilterEngine
       scope,
       column,
       value,
-      table_name
+      table_name,
+      negate: false
     )
-
       apply_condition(
         scope,
         column,
         Array(value),
-        table_name
+        table_name,
+        negate: negate
       )
     end
 
@@ -210,19 +235,20 @@ module BharatFilterEngine
       scope,
       column,
       value,
-      table_name
+      table_name,
+      negate: false
     )
-
       cast_value =
         ActiveModel::Type::Boolean
-          .new
-          .cast(value)
+        .new
+        .cast(value)
 
       apply_condition(
         scope,
         column,
         cast_value,
-        table_name
+        table_name,
+        negate: negate
       )
     end
 
@@ -230,41 +256,92 @@ module BharatFilterEngine
       scope,
       column,
       value,
-      table_name
+      table_name,
+      negate: false
     )
-
       apply_condition(
         scope,
         column,
         value,
-        table_name
+        table_name,
+        negate: negate
       )
     end
 
-    # Shared by array/boolean/string/exact-numeric filters: applies a
-    # plain equality (or IN, for arrays) condition, qualifying it by
-    # table_name when the filter comes from a joined association.
-    def apply_condition(scope, column, value, table_name)
-      if table_name
+    def apply_presence_filter(scope, column, value, table_name)
+      present = ActiveModel::Type::Boolean.new.cast(value)
+
+      arel_column =
+        if table_name
+          Arel::Table.new(table_name)[column]
+        else
+          scope.klass.arel_table[column]
+        end
+
+      if present
         scope.where(
-          table_name => {
-            column => value
-          }
+          arel_column.not_eq(nil).and(
+            arel_column.not_eq('')
+          )
         )
       else
         scope.where(
-          column => value
+          arel_column.eq(nil).or(
+            arel_column.eq('')
+          )
+        )
+      end
+    end
+
+    def apply_condition(scope, column, value, table_name, negate: false)
+      if negate && value.is_a?(Array)
+        return apply_negated_array_condition(
+          scope,
+          column,
+          value,
+          table_name
         )
       end
+
+      condition =
+        if table_name
+          { table_name => { column => value } }
+        else
+          { column => value }
+        end
+
+      negate ? scope.where.not(condition) : scope.where(condition)
     end
 
+    def apply_negated_array_condition(scope, column, values, table_name)
+      arel_column =
+        if table_name
+          Arel::Table.new(table_name)[column]
+        else
+          scope.klass.arel_table[column]
+        end
+
+      membership = arel_column.in(values.compact)
+
+      predicate =
+        if values.include?(nil)
+          arel_column.eq(nil).or(membership)
+        else
+          membership
+        end
+
+      scope.where(Arel::Nodes::Not.new(predicate))
+    end
+
+    NUMERIC_PATTERN = /\A[+-]?\d+(\.\d+)?\z/
+
     def apply_numeric_filter(
       scope,
       rule,
       value,
+      caster,
       table_name: nil
     )
-
       column =
         rule[:dbcolumn]
 
@@ -278,36 +355,80 @@ module BharatFilterEngine
       case rule[:range_type]
 
       when :gte
+        return scope unless numeric_string?(value)
 
-        scope.where(
-          "#{qualified_column} >= ?",
-          value
-        )
+        scope.where("#{qualified_column} >= ?", cast_numeric(value, caster))
 
       when :lte
+        return scope unless numeric_string?(value)
 
-        scope.where(
-          "#{qualified_column} <= ?",
-          value
+        scope.where("#{qualified_column} <= ?", cast_numeric(value, caster))
+
+      when :between
+        apply_numeric_between(
+          scope,
+          qualified_column,
+          value,
+          caster
         )
 
       else
+        return scope unless numeric_string?(value)
+
         apply_condition(
           scope,
           column,
-          value,
-          table_name
+          cast_numeric(value, caster),
+          table_name,
+          negate: rule[:negate]
         )
       end
     end
 
+    def apply_numeric_between(scope, qualified_column, value, caster)
+      return scope unless value.present?
+
+      raw_from, raw_to =
+        extract_bounds(value)
+
+      return scope unless
+        raw_from.present? || raw_to.present?
+
+      if raw_from.present? && numeric_string?(raw_from)
+        from =
+          cast_numeric(raw_from, caster)
+      end
+
+      if raw_to.present? && numeric_string?(raw_to)
+        to =
+          cast_numeric(raw_to, caster)
+      end
+
+      return scope unless from || to
+
+      if from && to
+        scope.where(qualified_column => from..to)
+      elsif from
+        scope.where("#{qualified_column} >= ?", from)
+      else
+        scope.where("#{qualified_column} <= ?", to)
+      end
+    end
+
+    def numeric_string?(value)
+      value.to_s.strip.match?(NUMERIC_PATTERN)
+    end
+
+    def cast_numeric(value, caster)
+      value.to_s.public_send(caster)
+    end
+
     def apply_date_range_filter(
       scope,
       rule,
       value,
       table_name: nil
     )
-
       return scope unless value.present?
 
       column =
@@ -320,42 +441,27 @@ module BharatFilterEngine
           column.to_s
         end
 
-      from, to =
-        case value
-
-        when Hash
-          [
-            value[:from] ||
-              value["from"],
-
-            value[:to] ||
-              value["to"]
-          ]
-
-        when Array
-          value
-
-        when String
-          value
-            .split(",")
-            .map(&:strip)
-
-        end
+      raw_from, raw_to =
+        extract_bounds(value)
 
       return scope unless
-        from.present? || to.present?
+        raw_from.present? || raw_to.present?
 
-      from =
-        normalize_date(
-          from,
-          :start
-        ) if from.present?
+      if raw_from.present?
+        from =
+          normalize_date(
+            raw_from,
+            :start
+          )
+      end
 
-      to =
-        normalize_date(
-          to,
-          :end
-        ) if to.present?
+      if raw_to.present?
+        to =
+          normalize_date(
+            raw_to,
+            :end
+          )
+      end
 
       if from.present? && to.present?
 
@@ -379,6 +485,28 @@ module BharatFilterEngine
       end
     end
 
+    def extract_bounds(value)
+      case value
+
+      when Hash
+        [
+          value[:from] || value['from'],
+          value[:to] || value['to']
+        ]
+
+      when Array
+        value
+
+      when String
+        value
+          .split(',')
+          .map(&:strip)
+
+      else
+        [nil, nil]
+      end
+    end
+
     def normalize_date(value, boundary)
       return value if
         value.is_a?(Time) ||
@@ -404,13 +532,11 @@ module BharatFilterEngine
 
     def deep_normalize_params(params)
       params.transform_values do |value|
-
         if value.is_a?(Hash)
           deep_normalize_params(value)
         else
           normalize_value(value)
         end
-
       end
     end
 
@@ -421,17 +547,17 @@ module BharatFilterEngine
       stripped =
         value.strip
 
-      if stripped.start_with?("[")
+      if stripped.start_with?('[')
         begin
           JSON.parse(stripped)
         rescue JSON::ParserError
           value
         end
 
-      elsif value.include?(",")
+      elsif value.include?(',')
 
         value
-          .split(",")
+          .split(',')
           .map(&:strip)
 
       else
@@ -440,4 +566,4 @@ module BharatFilterEngine
       end
     end
   end
-end
+end

data/lib/bharat_filter_engine/errors.rb

@@ -12,4 +12,4 @@ module BharatFilterEngine
 
   class InvalidAssociationError < Error
   end
-end
+end