rails-simple-search 1.1.10 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bbf2eecbbb512c647a434d6f6d1f928652cfeafa00c8c52226a88c1ec6bc23c
-  data.tar.gz: 8b32419b7e0daa8baa581dfd96e04b08513960bbc1a628bda321c12493de6a08
+  metadata.gz: 163e11eed3a64c95ca420d49bd6ade5d62bfeaeaff693b3b9586a387f89b7ae1
+  data.tar.gz: adb762be25ea2e2672d400667764728ca051df3dba97604610f4a5fe43f7d64b
 SHA512:
-  metadata.gz: 9032b02b2027ee62b51680ed8310ccf7579a8eef33494f6536dfc91f414f853bff2496ee53fb875dccfd52f84e60dacea7d3221eba27d51bc5ceafc73873be63
-  data.tar.gz: 796835f0e60438a36e52783eac52e0fdecf9e4ff3fd9789aa53f95396cdae797d1567c9477dea2fb3e773893950bc8aea54b3ed1f7f0c54b4c164deab0c1c28f
+  metadata.gz: d5f332112cbb55e5d966c4d0bba3044a19f56b0923ccc7f256b59fdcdee2d0e83d3708db5ffc718910b7fbe241c3f6480e5503be02ceb967603443ae5942dff7
+  data.tar.gz: 765ce655040b6488cb7137fa56afdc9fa3abcee70ca718f6972e0a9f8317ccb794cef9834b071638fc5a96689a22a217fd09c894787ba7d970b6df9a4a0b7ad1

data/README.md

@@ -1,10 +1,30 @@
+[![Gem Version](https://badge.fury.io/rb/rails-simple-search.svg)](https://badge.fury.io/rb/rails-simple-search)
+
+### Table of Contents
+
+* [What is rails-simple-search?](#what-is-rails-simple-search)
+
+* [Why rails-simple-search?](#why-rails-simple-search)
+
+* [Installation](#installation)
+
+* [Usage](#usage)
+
+* [How to construct field names](#how-to-construct-field-names)
+
+* [Demo projects](#demo-projects)
+
+* [Version history](#version-history)
+
+* [License](#license)
+
 ## What is rails-simple-search?
 rails-simple-search is a Ruby gem. It can help Ruby on Rails developers **quickly**
 implement searching/filtering function against database. If you're not looking
 for a full-text searching solution, this plugin will most probably **satisfy all**
 your searching requirement.
 
-## Why?
+## Why rails-simple-search?
 From time to time, I need to build pages to show a list of narrowed down records
 from a database table by giving some searching criteria on some columns of the
 table and/or of some referencing tables. Before I implemented this plugin, I usually
@@ -67,6 +87,8 @@ The following is how we implement this searching function with rails-simple-sear
 ```
 
 4. Code in views:
+   **Pay attention to the name of the form fields**.
+
 ```
     <% form_for @search, url => "/xxxxxx", data: {turbo: false} do |f| %>
 
@@ -89,7 +111,7 @@ The following is how we implement this searching function with rails-simple-sear
       <%=f.text_field "address.city" %>                    <!-- address is an association of model User -->
 
       <%=f.label "name of any one who commented to my posts" %>
-      <%=f.text_field "posts.comments.author.first_name_or_posts.comments.author.last_name" %> 
+      <%=f.text_field "posts.comments.user.first_name_or_posts.comments.user.last_name" %>
                                                            <!-- the associations could go even deeper, isn't it POWERFUL? -->
 
       <%=f.submit %>
@@ -105,6 +127,50 @@ The following is how we implement this searching function with rails-simple-sear
     post "/xxxxxx" => "yyyyyyy#zzzzzz"
 ```
 
+## How to construct field names
+1. Let's call the model we're search for is the base model. If you just want to search
+against any direct fields of the base model, we just use the table field name as the html
+input field name. For example
+```
+   "email"
+```
+
+2. If you need to search against fields of the base model's association, you can just
+use the association name and the table field name with a dot "." connecting them. Like this
+```
+   "address.city"
+```
+
+3. You can chain the associations more than 2 layers. For example, we're going to
+find out the users whose posts have been commented by someone whose first name we happen to know.
+```
+   "posts.comments.user.first_name"
+```
+
+4. Sometimes we need to find out something according to a range of time, or a range of numbers,
+we can attach "_greater_than", "_greater_than_equal_to", "_less_than", or "_less_than_equal_to".
+For example, we need to find out the users who birth date is between a range, the field names
+can be like this
+```
+   birth_date_greater_than
+```
+and
+```
+   birth_date_greater_than
+```
+
+5. Sometimes we need to express the idea of "or", for example, I know roughly a user's name, but
+not sure if it's her first name or last name, we can do it like this
+```
+   first_name_or_last_name
+```
+
+6. We can even use the "or" relation with association fields. For example
+```
+   posts.comments.user.first_name_or_posts.comments.user.last_name
+```
+
+
 ## Demo projects
 There are 2 demo projects for this gem, one for [Rails 5](https://github.com/yzhanginwa/demo_app_for_rails_simple_search)
 and one for [Rails 7](https://github.com/yzhanginwa/rails_simple_search_demo). You are encouraged to clone them to your local and
@@ -122,7 +188,7 @@ From version 1.1.0 on, we started to support the "or" relation, e.g., we can use
 
 From version 1.1.3 on, we started to support Rails 5.
 
-For Rails 7, please use version 1.1.9.
+For Rails 7, please use version 1.2.0.
 
 ## License
 

data/lib/sql_handler.rb

@@ -1,7 +1,7 @@
 module RailsSimpleSearch
   module SqlHandler
     def init
-      @table_name = @model_class.table_name
+      @model_table_name = @model_class.table_name
       @joins = {}
     end
 
@@ -36,7 +36,7 @@ module RailsSimpleSearch
       joins.each do |j|
         table = j[1]
         constrain = j[2]
-        @joins_str << " inner join #{table} on #{constrain}"
+        @joins_str << format(" inner join #{table} AS A%02d on #{constrain}", j[0])
       end
     end
 
@@ -45,16 +45,17 @@ module RailsSimpleSearch
       @condition_group.set_relation(:and)
 
       @criteria.each do |key, value|
-        @condition_group.add(parse_attribute(key, value))
+        @condition_group.add(parse_search_parameters(key, value))
       end
 
       make_joins
     end
 
-    def insert_condition(base_class, field, value)
+    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
@@ -65,17 +66,22 @@ module RailsSimpleSearch
         verb = 'in'
       elsif operator
         verb = operator
-      elsif text_column?(column) && ! @config[:exact_match].include?((@table_name == table) ? field : key)
+      elsif text_column?(column) && ! @config[:exact_match].include?((@model_table_name == table) ? field : key)
         verb = 'like'
         value = "%#{value}%"
       else
         verb = '='
       end
 
-      ConditionGroup.new(ConditionItem.new(key, verb, value))
+      ConditionGroup.new(ConditionItem.new(final_key, verb, value))
     end
 
-    def insert_join(base_class, asso_ref)
+    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)
+      debugger
       base_table = base_class.table_name
       asso_table = asso_ref.klass.table_name
 
@@ -84,45 +90,57 @@ module RailsSimpleSearch
       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}.#{asso_ref.foreign_key} = #{asso_table}.#{asso_ref.klass.primary_key}"]
+        @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}.#{base_class.primary_key} = #{asso_table}.#{asso_ref.foreign_key}"
-        join_cond = "#{asso_table}.#{asso_ref.type} = '#{base_class.name}' and #{join_cond}" if asso_ref.type
+        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
 
-    def parse_attribute(attribute, value)
+    # 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_attribute(a, value))
+          cg.add(parse_search_parameters(a, value))
         end
         return cg
       end
 
+      # handle direct fields
       unless attribute =~ /\./
-        condition = insert_condition(@model_class, attribute, value)
+        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])
+        insert_join(base_class, association_fields[0], new_asso_chain)
+        new_asso_chain = false
         base_class = association_fields.shift.klass
       end
 
-      insert_condition(base_class, field, value)
+      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
 
@@ -133,6 +151,9 @@ module RailsSimpleSearch
     end
   end
 
+  # This class holds a ConditionGroup
+  # One ConditionGroup can hold one or more
+  # conditions
   class ConditionGroup
     def initialize(item = nil)
       if item

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-simple-search
 version: !ruby/object:Gem::Version
-  version: 1.1.10
+  version: 1.2.1
 platform: ruby
 authors:
 - Yi Zhang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-26 00:00:00.000000000 Z
+date: 2023-12-27 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.
@@ -32,7 +32,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="