rad_core_rails 0.7.4 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9e0668296a4c9eaf8a2ee096c59affeb7b72a95174ed1e15716f250ee08a083
-  data.tar.gz: 91a4ceb121b1439519e451ca319357954bd62782c981752643def0cc7a9f4887
+  metadata.gz: '014856ac16f8d40063feb80c47e97120f02ddcf2f8a6717fad3472aefb6c0e4b'
+  data.tar.gz: d0ec03250fb3b8b868ce3694b3d029b86469563d9fede11fb8b34b690ea2fef5
 SHA512:
-  metadata.gz: 9251d1a8bc39a8cefb863f0d6ba26d88e0059bc04cb2bdd14a53ee897a7f53ee85f4400d188433e0b8dba3266bf09caa7c6246c4354aa6df72c32a00d00c88db
-  data.tar.gz: fbe6961987af27557a37113c2a03977b28fa3df008ed921a663ad32ba586920e935cc6ddb409b06d43155f9ebbbad244fdc181bf908937142f85bb94ba9cd201
+  metadata.gz: 410ed03d6ddd007f220ce1ceeeea8cedc1a7df95b044d8417ed7d11a00579b8eb980befc9fc2fc81dde7131502dcba08bb1d462bb50a0fe34cf577be9e606a27
+  data.tar.gz: 4a1fe8b16e4bda9f0631624cd769d67610a67efbd6c59e012c0c68b13f8b50496fbc8e5e08a3a6c69a5280537bf30f77a0cd55064537253224950e577c587a02

data/lib/rad_core_rails/query_generator.rb

@@ -24,15 +24,16 @@ module RadCoreRails
         @filter_manifest || {}.with_indifferent_access
       end
 
-      def create_filters(search, filters)
+      def create_filters(filters)
         query = []
         args = []
-        clause, arguments = generate_search_clause(search)
-        query << clause
-        arguments.each do |arg|
-          args << arg
-        end
-        filters.map do |filter|
+        # clause, arguments = generate_search_clause(search)
+        # query << clause
+        # arguments.each do |arg|
+        #   args << arg
+        # end
+        filters.map do |raw_filter|
+          filter = raw_filter.with_indifferent_access
           begin
             clause, arguments = filter_manifest[filter[:key]].call(filter)
             query << clause
@@ -46,92 +47,126 @@ module RadCoreRails
         [query.reject(&:blank?).join(' AND '), args]
       end
 
-      # def generate_search_clause(search)
-      #   and_args = []
-      #   or_args = []
-      #   if search.present? && searchable_columns.is_a?(Array)
-      #     # search_term_size = search.split(' ').length
-      #     and_terms = search.split(' ').select { |term| !term.include?('+') }
-      #     or_terms = search.split(' ').select { |term| term.include?('+') }
-      #     and_columns = []
-      #     or_columns = []
-      #     # just_ors = search_term_size == or_term_size
-      #     # operand = just_ors ? 'OR' : 'AND'
-      #     # search_terms = just_ors == true ? search.split(' ') : search.split(' ').select { |term| !term.include?('+') }
-      #     and_terms.each do |term|
-      #       columns = []
-      #       and_terms.each do |col|
-      #         and_columns.push("(LOWER(#{col}) ILIKE ?)")
-      #         and_args.push '%' + term.downcase.strip + '%'
-      #       end
-      #       or_terms.each do |col|
-      #         columns.push("(LOWER(#{col}) ILIKE ?)")
-      #         or_args.push '%' + term[1, term.length].downcase.strip + '%'
-      #       end
-      #       clause = if or_columns.empty?
-      #                  '(' + and_columns.join(' OR ') + ')'
-      #                else
-      #                  '(' + '(' + and_columns.join(' OR ') + ')' + 'AND' + '(' + or_columns.join(' OR ') + ')' + ')'
-      #                         end
-      #     end
-      #     [clause, and_args + or_args]
-      #   else
-      #     ['', []]
-      #   end
-      # end
-
-      # @searchable_columns, is an array of column names that you can compare to your terms.
-      #
-      def generate_search_clause(search)
+      def generate_search_clause(filter)
+        search = filter[:values][0]
+        search_clause = ['', []]
+
         if search.present? && searchable_columns.is_a?(Array)
-          # holds all of the sql from sanitized_and_terms
-          and_args = []
-          # holds all the table columns sql for all the AND terms
-          and_clause = []
-          # holds all of the sql from sanitized_or_terms
-          or_args = []
-          # holds all the table columns sql for all the OR terms
-          or_clause = []
-          # extract and terms, remove casing, and add ILIKE '%' comparisions
+          and_args = []         # SQL from sanitized_and_terms
+          excluded_args = []    # SQL from sanitized_excluded_terms
+          and_clause = []       # table columns SQL for all the AND terms
+          excluded_clause = []  # table columns SQL for all the AND NOT terms
+          or_args = []          # SQL from sanitized_or_terms
+          or_clause = []        # table columns SQL for all the OR terms
+
+          phrases_or = search.scan(/\+"([^"]*)"/) # e.g. +"Phrase for OR"
+          # remove 'or' phrases from search if any
+          phrases_or.each { |phrase| search.gsub!('+"' + phrase.first.to_s + '"', '') } if phrases_or.any?
+
+          phrases_to_exclude = search.scan(/-"([^"]*)"/) # e.g. -"Phrase to exclude"
+          # remove excluded phrases from search if any
+          if phrases_to_exclude.any?
+            phrases_to_exclude.each { |phrase| search.gsub!('-"' + phrase.first.to_s + '"', '') }
+          end
+
+          phrases_and = search.scan(/"([^"]*)"/) # e.g. "Phrase for AND"
+          # remove 'and' phrases from search if any
+          phrases_and.each { |phrase| search.gsub!('"' + phrase.first.to_s + '"', '') } if phrases_and.any?
+
+          # extract 'and' terms, remove casing, and add ILIKE '%' comparisons
           sanitized_and_terms = search.split(' ')
-                                      .reject { |term| term.include?('+') }
+                                      .reject { |term| term.include?('+') || term.include?('-') }
                                       .map { |term| '%' + term.downcase.strip + '%' }
-          # extract or terms, remove casing, and add ILIKE '%' comparisions
+          # add 'and' phrase terms, remove casing, and add ILIKE '%' comparisons
+          if phrases_and.any?
+            sanitized_and_terms += phrases_and.flatten.map { |phrase| '%' + phrase.downcase.strip + '%' }
+          end
+
+          # extract 'or' terms, remove casing, and add ILIKE '%' comparisons
           sanitized_or_terms = search.split(' ')
                                      .select { |term| term.include?('+') }
                                      .map { |term| '%' + term[1, term.length].downcase.strip + '%' }
+
+          # add 'or' phrase terms, remove casing, and add ILIKE '%' comparisons
+          sanitized_or_terms += phrases_or.flatten.map { |phrase| '%' + phrase.downcase.strip + '%' } if phrases_or.any?
+
+          # extract excluded terms, remove casing, and add NOT ILIKE '%' comparisons
+          sanitized_excluded_terms = search.split(' ')
+                                           .select { |term| term.include?('-') }
+                                           .map { |term| '%' + term[1, term.length].downcase.strip + '%' }
+
+          # add excluded phrase terms, remove casing, and add NOT ILIKE '%' comparisons
+          if phrases_to_exclude.any?
+            sanitized_excluded_terms += phrases_to_exclude.flatten
+                                                          .map { |phrase| '%' + phrase.downcase.strip + '%' }
+          end
+
           # loop through sanitized_and_terms to find all possible columns.
           sanitized_and_terms.each do |sanitized_term|
             columns = []
             # all possible columns where this should be searched
             searchable_columns.each do |col|
-              columns.push("(LOWER(#{col}) ILIKE ?)")
+              columns.push("(COALESCE(LOWER(#{col}), '') ILIKE ?)")
               and_args.push sanitized_term
             end
             and_clause.push '(' + columns.join(' OR ') + ')'
           end
+          # loop through sanitized_excluded_terms to find all possible columns.
+          sanitized_excluded_terms.each do |sanitized_term|
+            columns = []
+            # all possible columns where this should be searched
+            searchable_columns.each do |col|
+              columns.push("(COALESCE(LOWER(#{col}), '') NOT ILIKE ?)")
+              excluded_args.push sanitized_term
+            end
+            excluded_clause.push '(' + columns.join(' AND ') + ')'
+          end
           # loop through sanitized_or_terms to find all possible columns.
           sanitized_or_terms.each do |sanitized_term|
             columns = []
             # all possible columns where this should be searched
             searchable_columns.each do |col|
-              columns.push("(LOWER(#{col}) ILIKE ?)")
+              columns.push("(COALESCE(LOWER(#{col}), '') ILIKE ?)")
               or_args.push sanitized_term
             end
             or_clause.push '(' + columns.join(' OR ') + ')'
           end
-          if or_clause.empty? && and_clause.empty?
-            ['', []]
-          elsif or_clause.empty?
-            ['(' + and_clause.join(' AND ') + ')', and_args]
-          elsif and_clause.empty?
-            ['(' + or_clause.join(' OR ') + ')', or_args]
-          else
-            ['((' + and_clause.join(' AND ') + ') AND (' + or_clause.join(' OR ') + '))', and_args + or_args]
+
+          return ['', []] if or_clause.empty? && and_clause.empty? && excluded_clause.empty?
+
+          return ['(' + and_clause.join(' AND ') + ')', and_args] if or_clause.empty? && excluded_clause.empty?
+
+          return ['(' + or_clause.join(' OR ') + ')', or_args] if and_clause.empty? && excluded_clause.empty?
+
+          return ['(' + excluded_clause.join(' AND ') + ')', excluded_args] if or_clause.empty? && and_clause.empty?
+
+          if or_clause.empty?
+            return ['((' + and_clause.join(' AND ') + ') AND (' + excluded_clause.join(' AND ') + '))',
+                    and_args + excluded_args]
           end
-        else
-          ['', []]
+
+          if and_clause.empty?
+            return ['((' + or_clause.join(' OR ') + ') AND (' + excluded_clause.join(' AND ') + '))',
+                    or_args + excluded_args]
+          end
+
+          if excluded_clause.empty?
+            return ['((' + and_clause.join(' AND ') + ') AND (' + or_clause.join(' OR ') + '))', and_args + or_args]
+          end
+
+          search_clause = [
+            '((' +
+              and_clause.join(' AND ') +
+              ') AND (' +
+              or_clause.join(' OR ') +
+              ') AND (' +
+              excluded_clause.join(' AND ') +
+              '))',
+            and_args + or_args + excluded_args
+          ]
         end
+
+        search_clause
       end
 
       # Generate Boolean clause
@@ -156,6 +191,77 @@ module RadCoreRails
         [str, args]
       end
 
+      def sanitize_vector_string(search)
+        phrases_or = search.scan(/\+"([^"]*)"/) # e.g. +"Phrase for OR"
+        # remove 'or' phrases from search if any
+        phrases_or.each { |phrase| search.gsub!('+"' + phrase.first.to_s + '"', '') } if phrases_or.any?
+
+        phrases_to_exclude = search.scan(/-"([^"]*)"/) # e.g. -"Phrase to exclude"
+        # remove excluded phrases from search if any
+        phrases_to_exclude.each { |phrase| search.gsub!('-"' + phrase.first.to_s + '"', '') } if phrases_to_exclude.any?
+
+        phrases_and = search.scan(/"([^"]*)"/) # e.g. "Phrase for AND"
+        # remove 'and' phrases from search if any
+        phrases_and.each { |phrase| search.gsub!('"' + phrase.first.to_s + '"', '') } if phrases_and.any?
+
+        sanitized_and_terms = search.split(' ')
+                                    .reject { |term| term.include?('+') || term.include?('-') }
+                                    .map { |term| term.downcase.strip + ':*' }
+                                    .reject { |t| t.blank? }
+
+        sanitized_or_terms = search.split(' ')
+                                   .select { |term| term.include?('+') }
+                                   .map { |term| term[1, term.length].downcase + ':*' }
+                                   .reject { |t| t.blank? }
+
+        sanitized_excluded_terms = search.split(' ')
+                                         .select { |term| term.include?('-') }
+                                         .map { |term| term[1, term.length].downcase.strip + ':*' }
+                                         .reject { |t| t.blank? }
+
+        and_clause = sanitized_and_terms.join(' & ')
+
+        or_clause = sanitized_or_terms.join(' | ')
+
+        excluded_clause = sanitized_excluded_terms.map { |t| "!#{t}" }.join(' & ')
+
+        # puts '------'
+        # puts '------'
+        # puts '------'
+        # puts and_clause.inspect
+        # puts or_clause.inspect
+        # puts excluded_clause.inspect
+        # puts '------'
+        # puts '------'
+
+        if and_clause.present? && or_clause.empty? && excluded_clause.empty?
+          and_clause
+        elsif and_clause.empty? && or_clause.present? && excluded_clause.empty?
+          or_clause
+        elsif and_clause.empty? && or_clause.empty? && excluded_clause.present?
+          excluded_clause
+        elsif and_clause.present? && or_clause.present? && excluded_clause.empty?
+          "(#{and_clause}) & (#{or_clause})"
+        elsif and_clause.present? && or_clause.empty? && excluded_clause.present?
+          "(#{and_clause}) & (#{excluded_clause})"
+        elsif and_clause.empty? && or_clause.present? && excluded_clause.present?
+          "(#{or_clause}) & (#{excluded_clause})"
+        elsif and_clause.present? && or_clause.present? && excluded_clause.present?
+          "(#{and_clause}) & (#{or_clause}) & (#{excluded_clause})"
+        else
+          raise StandardError, 'Combination not available.'
+        end
+      end
+
+      def generate_vector_clause(column_name, filter)
+        return ['', []] if filter[:values][0].blank?
+
+        vector_string = sanitize_vector_string(filter[:values][0])
+
+        query = "(#{column_name} @@ to_tsquery('simple', ?))"
+        [query, [vector_string]]
+      end
+
       def generate_zip_codes_clause(column_name, filter)
         str = "(#{column_name} = ANY(#{zip_code_class.distance_query}))"
         args = zip_code_class.distance_args(filter)
@@ -165,10 +271,10 @@ module RadCoreRails
 
       def generate_array_clause(column_name, filter)
         if filter[:option] == '!='
-          str = "(SELECT NOT(#{column_name}::text[] && ARRAY[?]))"
+          str = "(SELECT NOT(#{column_name}::text[] && ARRAY[?]::text[]))"
           args = [filter[:values]]
         else
-          str = "(SELECT (#{column_name}::text[] && ARRAY[?]))"
+          str = "(SELECT (#{column_name}::text[] && ARRAY[?]::text[]))"
           args = [filter[:values]]
         end
 

data/lib/rad_core_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RadCoreRails
-  VERSION = '0.7.4'
+  VERSION = '0.8.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rad_core_rails
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.8.3
 platform: ruby
 authors:
 - Oleksandr Poltavets, James Marrs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-13 00:00:00.000000000 Z
+date: 2021-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport