rails-simple-search 1.2.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6310535f7e545c8b29ca69421df5a8f23efca79dab7ccec6311ed00c632c51d
-  data.tar.gz: 5379c314d28a7e06acf4e12ec23d78799e81b89843d1abf2717122e2f90cbbfc
+  metadata.gz: 2fcf45308630c8fda4c1b7ecce567017b0a77377060aff73ca41600405d2b8a5
+  data.tar.gz: 585040de107d0abf032daf209ad2cd83cfb45ec04ae3276dbb47730060270d2d
 SHA512:
-  metadata.gz: 25829545f58e17b7234400719ef2707369cc2a5dbd608d3527c1aafd9a41cf7a5189e4f04857ea263887307faaaa66cce9850c8af024e450fd98095c95ea2989
-  data.tar.gz: 47bc9c46c5c56017bc1b6c468e811987f1738e1f38c4379217d77f474c62c640bbf1d9e154d7eaa099905b3337f7819d937718964b441af2c6c87958eb169259
+  metadata.gz: cfb6223b4b906b2d4ef3e748c6c794c62bad9813c1cbfef9b220523826f0e3691874a9426ff2c9bd18fad09cf30b55782d24775efa13f282a187f7a357437247
+  data.tar.gz: 7b6c4c9057c3c0425c362253417932db84ef434771aa43118af9de14530e8ae3a5594e9484e2de3c080c9dc7cc46088ec830fb56775d1800aff6d2e5c971ed0e

data/lib/selection_group.rb

@@ -0,0 +1,64 @@
+require_relative 'selection_item'
+
+# frozen_string_literal: true
+module RailsSimpleSearch
+  module SqlHandler
+    # this class is to represent a sql select statements, union of select
+    # statements, or intersect of select statements
+    class SelectionGroup
+      def self.union_alias_count
+        @union_alias_count ||= 0
+        @union_alias_count += 1
+        @union_alias_count
+      end
+
+      def initialize(item = nil)
+        @selection_item = item if item
+        @children = []
+      end
+
+      def add_child(condition_group)
+        raise "It's not allowed to add child into leaf node" if leaf?
+
+        @children << condition_group if condition_group
+      end
+
+      def add_item(selection_item)
+        raise "It's not allowed to add item into non-leaf node" unless empty?
+
+        @selection_item = selection_item
+      end
+
+      def relation(and_or)
+        raise "It's no need to set relation for leaf node" if leaf?
+
+        @relation = and_or
+      end
+
+      def leaf?
+        @selection_item ? true : false
+      end
+
+      def empty?
+        @children.empty? ? true : false
+      end
+
+      def to_sql
+        if leaf?
+          @selection_item.to_sql
+        elsif @relation == :or
+          unioned_sql = @children.map(&:to_sql).join(' union ')
+          "select * from ( #{unioned_sql} ) as #{union_alias}"
+        elsif @relation == :and
+          @children.map(&:to_sql).join(' intersect ')
+        else
+          raise "This should not happen"
+        end
+      end
+
+      def union_alias
+        "union_alias_#{self.class.union_alias_count}"
+      end
+    end
+  end
+end

data/lib/selection_item.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+module RailsSimpleSearch
+  module SqlHandler
+    # this class represents a single select statement, without unions or intersects.
+    class SelectionItem
+      attr_reader :field, :value
+
+      def initialize(config, model_class, field, value)
+        @config = config
+        @model_class = model_class
+        @field = field
+        @value = value
+        @joins = {}
+        @verb = ''
+      end
+
+      def to_sql
+        build_select_with_condition(@field, @value)
+        join_str = make_joins
+        query = @model_class.joins(join_str)
+        query = query.where(to_ar_condition)
+        query = query.select("distinct #{@model_class.table_name}.*")
+        query.to_sql
+      end
+
+      private
+
+      # This method parse a search parameter and its value
+      # then produce a ConditionGroup
+      def build_select_with_condition(attribute, value)
+        # handle direct fields
+        unless attribute =~ /\./
+          condition = build_single_condition(@model_class, @model_class.table_name, attribute, value)
+          return condition
+        end
+
+        # handle association fields
+        association_fields = attribute.split(/\./)
+        field = association_fields.pop
+
+        base_class = @model_class
+        new_asso_chain = true
+        while (current_association_string = association_fields.shift)
+          # polymorphic association with solid target table_name
+          # such as 'commentable:post'
+          if current_association_string.include?(':')
+            poly_asso_name, poly_asso_type = current_association_string.split(':')
+            current_association = base_class.reflect_on_association(poly_asso_name.to_sym)
+            poly_asso_type_class = poly_asso_type.downcase.camelize.constantize
+            insert_join(base_class, current_association, new_asso_chain, poly_asso_type_class)
+            base_class = poly_asso_type_class
+          else
+            current_association = base_class.reflect_on_association(current_association_string.to_sym)
+            insert_join(base_class, current_association, new_asso_chain)
+            base_class = current_association.klass
+          end
+
+          new_asso_chain = false
+        end
+
+        association_alias = table_name_to_alias(base_class.table_name)
+        build_single_condition(base_class, association_alias, field, value)
+      end
+
+      def build_single_condition(base_class, association_alias, field, value)
+        field, operator = parse_field_name(field)
+        table = base_class.table_name
+        key = "#{table}.#{field}"
+        final_key = "#{association_alias}.#{field}"
+
+        column = base_class.columns_hash[field.to_s]
+        return nil unless column
+
+        if value.nil?
+          verb = 'is'
+        elsif value.is_a?(Array)
+          verb = 'in'
+        elsif operator
+          verb = operator
+        elsif text_column?(column) && ! @config[:exact_match].include?((@model_table_name == table) ? field : key)
+          verb = 'like'
+          value = "%#{value}%"
+        else
+          verb = '='
+        end
+
+        @final_key = final_key
+        @verb = verb
+        @value = value
+      end
+
+      def insert_join(base_class, asso_ref, new_asso_chain, poly_asso_type_class=nil)
+        return if asso_ref.polymorphic? && poly_asso_type_class.blank?
+        base_table = base_class.table_name
+        asso_table = poly_asso_type_class&.table_name || asso_ref.klass.table_name
+
+        @join_count ||= 0
+        return if base_table == asso_table
+        return unless @joins[asso_table].nil?
+
+        @join_count += 1
+        base_table_alias = new_asso_chain ? base_table : table_name_to_alias(base_table)
+        asso_table_alias = format('A%02d', @join_count)
+
+        if asso_ref.belongs_to?
+          if asso_ref.polymorphic?
+            join_cond = "#{base_table_alias}.#{asso_ref.foreign_key} = #{asso_table_alias}.#{poly_asso_type_class.primary_key}"
+            join_cond = "#{base_table_alias}.#{asso_ref.foreign_type} = '#{poly_asso_type_class.name}' and #{join_cond}"
+          else
+            join_cond = "#{base_table_alias}.#{asso_ref.foreign_key} = #{asso_table_alias}.#{asso_ref.klass.primary_key}"
+          end
+        else
+          join_cond = "#{base_table_alias}.#{base_class.primary_key} = #{asso_table_alias}.#{asso_ref.foreign_key}"
+          join_cond = "#{asso_table_alias}.#{asso_ref.type} = '#{base_class.name}' and #{join_cond}" if asso_ref.type
+        end
+        @joins[asso_table] = [@join_count, asso_table, join_cond]
+      end
+
+      def table_name_to_alias(table_name)
+        format('A%02d', @joins[table_name][0])
+      end
+
+      def parse_field_name(name)
+        if name =~ /^(.*)?((_(greater|less)_than)(_equal_to)?)$/
+          field_name = ::Regexp.last_match(1)
+          operator = (::Regexp.last_match(4) == 'greater' ? '>' : '<')
+          operator << '=' if ::Regexp.last_match(5)
+        else
+          field_name = name
+        end
+
+        [field_name, operator]
+      end
+
+      def text_column?(column)
+        if column.respond_to?(:text?)
+          column.text?
+        elsif column.respond_to?(:type)
+          column.type == :string || column.type == :text
+        else
+          raise 'encountered new version of Rails'
+        end
+      end
+
+      def make_joins
+        joins_str = ''
+        joins = @joins.values
+        joins.sort! { |a, b| a[0] <=> b[0] }
+        joins.each do |j|
+          table = j[1]
+          constrain = j[2]
+          joins_str += format(" inner join #{table} AS A%02d on #{constrain}", j[0])
+        end
+        joins_str
+      end
+
+      def to_ar_condition
+        condition = []
+        condition << "#{@final_key} #{@verb}"
+        condition[0] << (@verb == 'in' ? ' (?)' : ' ?')
+        condition << @value
+        condition
+      end
+    end
+  end
+end

data/lib/sql_handler.rb

@@ -1,3 +1,38 @@
+require_relative 'selection_group.rb'
+require_relative 'selection_item.rb'
+
+# This gem returns some rows of a certain table (model), according to the search parameters.
+# Each search parameter can ba a direct field (like first_name, last_name), indirect
+# field (like address.city, posts.comments.author.first_nane), or composite field
+# (like, address.city_or_posts.comments.author.city).
+#
+# For example, if we have 3 search parameters, {"serach":{"aaa":"aaa"}, {"bbb.ccc":"ccc"}, {"ddd.eee_or_ggg.hhh":"hhh"}}
+# The psudo result sql statement would look like:
+#
+#   select * from base_model
+#     where aaa = 'aaa'
+#
+#   intersect
+#
+#   select * from base_model
+#     join xxxxxx
+#     where ccc = 'ccc'
+#
+#   intersect
+#
+#   select * from
+#   (
+#     select * from base_model
+#       join xxxxxx
+#       where eee = 'ccc'
+#
+#     union
+#
+#     select * from base_model
+#       join xxxxxx
+#       where hhh= 'ccc'
+#   ) as union_result_1
+#
 module RailsSimpleSearch
   module SqlHandler
     def init
@@ -10,196 +45,56 @@ module RailsSimpleSearch
         instance_eval(&pre_processor)
       end
 
-      run_criteria
+      selection_group = generate_selection_group(@criteria)
 
-      query = @model_class.joins(@joins_str)
-      query = query.where(@condition_group.to_ar_condition) unless @condition_group.empty?
-      query.select("distinct #{@model_class.table_name}.*")
-    end
-
-    private
-
-    def text_column?(column)
-      if column.respond_to?(:text?)
-        column.text?
-      elsif column.respond_to?(:type)
-        column.type == :string || column.type == :text
+      raw_sql = selection_group.to_sql
+      if raw_sql.blank?
+        @model_class.all
       else
-        raise 'encountered new version of Rails'
+        @model_class.from("(#{raw_sql}) AS #{@model_table_name}")
       end
     end
 
-    def make_joins
-      @joins_str = ''
-      joins = @joins.values
-      joins.sort! { |a, b| a[0] <=> b[0] }
-      joins.each do |j|
-        table = j[1]
-        constrain = j[2]
-        @joins_str << format(" inner join #{table} AS A%02d on #{constrain}", j[0])
-      end
-    end
+    private
 
-    def run_criteria
-      @condition_group = ConditionGroup.new
-      @condition_group.set_relation(:and)
+    def generate_selection_group(criteria)
+      selection_group = SelectionGroup.new
+      selection_group.relation(:and)
+
+      criteria.each do |key, value|
+        sg = SelectionGroup.new
+        fields = key.split(@config[:or_separator])
+        if fields.size > 1
+          # if the key is "or"ed by muiltiple fields
+          # we generate a SelectionGroup to include all the fields
+          sg.relation(:or)
+          fields.each do |f|
+            si = SelectionItem.new(@config, @model_class, f, value)
+            sg_si = SelectionGroup.new(si)
+            sg.add_child(sg_si)
+          end
+        else
+          sg.add_item(SelectionItem.new(@config, @model_class, fields.first, value))
+        end
 
-      @criteria.each do |key, value|
-        @condition_group.add(parse_search_parameters(key, value))
+        selection_group.add_child(sg)
       end
 
-      make_joins
+      selection_group
     end
 
-    def build_single_condition(base_class, association_alias, field, value)
-      field, operator = parse_field_name(field)
-      table = base_class.table_name
-      key = "#{table}.#{field}"
-      final_key = "#{association_alias}.#{field}"
-
-      column = base_class.columns_hash[field.to_s]
-      return nil unless column
-
-      if value.nil?
-        verb = 'is'
-      elsif value.is_a?(Array)
-        verb = 'in'
-      elsif operator
-        verb = operator
-      elsif text_column?(column) && ! @config[:exact_match].include?((@model_table_name == table) ? field : key)
-        verb = 'like'
-        value = "%#{value}%"
+    def text_column?(column)
+      if column.respond_to?(:text?)
+        column.text?
+      elsif column.respond_to?(:type)
+        column.type == :string || column.type == :text
       else
-        verb = '='
+        raise 'encountered new version of Rails'
       end
-
-      ConditionGroup.new(ConditionItem.new(final_key, verb, value))
     end
 
     def table_name_to_alias(table_name)
       format('A%02d', @joins[table_name][0])
     end
-
-    def insert_join(base_class, asso_ref, new_asso_chain)
-      base_table = base_class.table_name
-      asso_table = asso_ref.klass.table_name
-
-      @join_count ||= 0
-      return if base_table == asso_table
-      return unless @joins[asso_table].nil?
-
-      @join_count += 1
-      base_table_alias = new_asso_chain ? base_table : table_name_to_alias(base_table)
-      asso_table_alias = format('A%02d', @join_count)
-
-      if asso_ref.belongs_to?
-        @joins[asso_table] =[@join_count, asso_table, "#{base_table_alias}.#{asso_ref.foreign_key} = #{asso_table_alias}.#{asso_ref.klass.primary_key}"]
-      else
-        join_cond = "#{base_table_alias}.#{base_class.primary_key} = #{asso_table_alias}.#{asso_ref.foreign_key}"
-        join_cond = "#{asso_table_alias}.#{asso_ref.type} = '#{base_class.name}' and #{join_cond}" if asso_ref.type
-        @joins[asso_table] = [@join_count, asso_table, join_cond]
-      end
-    end
-
-    # This method parse a search parameter and its value
-    # then produce a ConditionGroup
-    def parse_search_parameters(attribute, value)
-      # handle _or_ parameters
-      attributes = attribute.split(@config[:or_separator])
-      if attributes.size > 1
-        cg = ConditionGroup.new
-        cg.set_relation(:or)
-        attributes.each do |a|
-          cg.add(parse_search_parameters(a, value))
-        end
-        return cg
-      end
-
-      # handle direct fields
-      unless attribute =~ /\./
-        condition = build_single_condition(@model_class, @model_class.table_name, attribute, value)
-        return condition
-      end
-
-      # handle association fields
-      association_fields = attribute.split(/\./)
-      field = association_fields.pop
-
-      base_class = @model_class
-      new_asso_chain = true
-      until association_fields.empty?
-        association_fields[0] = base_class.reflect_on_association(association_fields[0].to_sym)
-        insert_join(base_class, association_fields[0], new_asso_chain)
-        new_asso_chain = false
-        base_class = association_fields.shift.klass
-      end
-
-      association_alias = table_name_to_alias(base_class.table_name)
-      build_single_condition(base_class, association_alias, field, value)
-    end
-  end
-
-  # This class holds a single condition
-  class ConditionItem
-    attr_reader :field, :verb, :value
-
-    def initialize(field, verb, value)
-      @field = field
-      @verb = verb
-      @value = value
-    end
-  end
-
-  # This class holds a ConditionGroup
-  # One ConditionGroup can hold one or more
-  # conditions
-  class ConditionGroup
-    def initialize(item = nil)
-      if item
-        @condition_item = item
-      else
-        @children = []
-      end
-    end
-
-    def add(condition_group)
-      raise "It's not allowed to add child into leaf node" if leaf?
-
-      @children << condition_group if condition_group
-    end
-
-    def set_relation(and_or)
-      raise "It's not needed to set relation for leaf node" if leaf?
-
-      @relation = and_or
-    end
-
-    def leaf?
-      @condition_item ? true : false
-    end
-
-    def empty?
-      @children && @children.empty? ? true : false
-    end
-
-    def to_ar_condition
-      condition = []
-      if leaf?
-        i = @condition_item
-        condition << "#{i.field} #{i.verb}"
-        condition[0] << (i.verb == 'in' ? ' (?)' : ' ?')
-        condition << i.value
-      else
-        tmp_conditions = @children.map(&:to_ar_condition)
-        tmp_condition_str = tmp_conditions.map(&:first).join(" #{@relation} ")
-        condition << "(#{tmp_condition_str})"
-        tmp_conditions.each do |t|
-          (1..(t.length - 1)).each do |index|
-            condition << t[index]
-          end
-        end
-      end
-      condition
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-simple-search
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Yi Zhang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-27 00:00:00.000000000 Z
+date: 2024-09-01 00:00:00.000000000 Z
 dependencies: []
 description: rails-simple-search is a light and easy to use gem. It could help developers
   quickly build a search page.
@@ -19,6 +19,8 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/rails-simple-search.rb
+- lib/selection_group.rb
+- lib/selection_item.rb
 - lib/sql_handler.rb
 homepage: http://github.com/yzhanginwa/rails-simple-search
 licenses:
@@ -39,7 +41,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: A very simple and light gem to quickly build search/filter function in rails