rokaki 0.8.1 → 0.8.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a4312a80ff21e5c59187f2677c803626aa2d9bd2331316dea46de60461c50fa
-  data.tar.gz: f2d1b2b2aeefb8f82cf7be3ecfe5f058472701ad23064a8909fe09e6c289e4d7
+  metadata.gz: 8f2a62792073dd9728a44158d6f30dc4f0f8119316bda3a3846c16fc2abc57f7
+  data.tar.gz: 80e9bfc7b677b7e291996c5bda1fc6652ddfbb592b31083446ef992755f00404
 SHA512:
-  metadata.gz: c4d9d19c3d0f008721cfe2cbae3364f29e46fc094edd03af7738999a5cbe3680606f9201d884d4ce1316d5ad3da54b1f572d8bec7bcc3a00cc60696e36a0db11
-  data.tar.gz: 2c83644c0338d9024422de614edb92d336ec542261f3453b07f5713e676e8c0c6c5947e8e75fb85bfde6f862185f56a9eac44664ea6769767dda2e901937b9ea
+  metadata.gz: 6570c3b380c66092b3a583b1c94a51f8364f06d936522cc72676e23c3aa1717b4b89cc65c0d3ed6e6d67291b3c7e1c3c83d8254acd7df8f9971700b314a71aa0
+  data.tar.gz: 913e7bf304da343a4dce4d061dbcdaa37c2f26d7a396e590e393a224a4ac7c30c439f8d085de1a865828c9931f1bcf99dc66b32c8494e8481dcc6c5539d03ea6

data/.gitignore

@@ -11,3 +11,4 @@
 .rspec_status
 tags
 *.gem
+TODO.md

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rokaki (0.8.1)
+    rokaki (0.8.3.1)
       activesupport
 
 GEM
@@ -21,6 +21,10 @@ GEM
     byebug (11.1.3)
     coderay (1.1.3)
     concurrent-ruby (1.1.6)
+    database_cleaner (1.8.5)
+    database_cleaner-active_record (1.8.0)
+      activerecord
+      database_cleaner (~> 1.8.0)
     diff-lcs (1.3)
     factory_bot (6.0.2)
       activesupport (>= 5.0.0)
@@ -90,6 +94,7 @@ PLATFORMS
 DEPENDENCIES
   activerecord
   bundler (~> 2.0)
+  database_cleaner-active_record
   factory_bot
   guard
   guard-rspec

data/README.md

@@ -1,4 +1,6 @@
 # Rokaki
+## You know, for air.
+
 [![Gem Version](https://badge.fury.io/rb/rokaki.svg)](https://badge.fury.io/rb/rokaki)
 
 This gem was born out of a desire to dry up filtering services in Rails apps or any Ruby app that uses the concept of "filters" or "facets".
@@ -46,7 +48,8 @@ class FilterArticles
 
   def filter_results
     @articles = @articles.where(date: date) if date
-    @articles = @articles.joins(:author).where(author: { first_name: author_first_name }) if author_first_name
+    @articles = @articles.joins(:author).where(authors: { first_name: author_first_name }) if author_first_name
+    @articles = @articles.joins(:author).where(authors: { last_name: author_last_name }) if author_last_name
   end
 end
 
@@ -98,6 +101,7 @@ advanced_filterable.advanced__filter_key_4__deep_leaf_array == [1,2,3,4]
 advanced_filterable.advanced__filter_key_1__filter_key_3__deep_node == 'NODE'
 ```
 ### `#define_filter_map`
+The define_filter_map method is more suited to classic "search", where you might want to search multiple fields on a model or across a graph. See the section on [filter_map](https://github.com/tevio/rokaki#2-the-filter_map-command-syntax) with OR for more on this kind of application.
 
 This method takes a single field in the passed in filters hash and maps it to fields named in the second param, this is useful if you want to search for a single value across many different fields or associated tables simultaneously.
 
@@ -115,7 +119,7 @@ class FilterMap
   define_filter_map :query, :mapped_a, association: :field
 end
 
-filter_map = FilterMap.new(fytlerz: { query: 'H2O' })
+filter_map = FilterMap.new(fylterz: { query: 'H2O' })
 
 filter_map.mapped_a == 'H2O'
 filter_map.association_field = 'H2O'
@@ -227,6 +231,88 @@ filtered_authors = AuthorFilter.new(filters: filters).results
 
 In the above example we search for authors who have written articles containing the word "Jiddu" in the title that also have reviews containing the sames word in their titles.
 
+The above example performs an "ALL" like query, where all fields must satisfy the query term. Conversly you can use `or` to perform an "ANY", where any of the fields within the `or` will satisfy the query term, like so:-
+
+
+```ruby
+class AuthorFilter
+  include Rokaki::FilterModel
+
+  filter_map :author, :query,
+    like: {
+      articles: {
+        title: :circumfix,
+        or: { # the or is aware of the join and will generate a compound join aware or query
+          reviews: {
+            title: :circumfix
+          }
+        }
+      },
+    }
+
+  attr_accessor :filters, :model
+
+  def initialize(filters:)
+    @filters = filters
+  end
+end
+
+filters = { query: "Lao" }
+filtered_authors = AuthorFilter.new(filters: filters).results
+```
+
+## CAVEATS
+Active record OR over a join may require you to add something like the following in an initializer in order for it to function properly:-
+
+### #structurally_incompatible_values_for_or
+
+``` ruby
+module ActiveRecord
+  module QueryMethods
+    def structurally_incompatible_values_for_or(other)
+      Relation::SINGLE_VALUE_METHODS.reject { |m| send("#{m}_value") == other.send("#{m}_value") } +
+        (Relation::MULTI_VALUE_METHODS - [:joins, :eager_load, :references, :extending]).reject { |m| send("#{m}_values") == other.send("#{m}_values") } +
+        (Relation::CLAUSE_METHODS - [:having, :where]).reject { |m| send("#{m}_clause") == other.send("#{m}_clause") }
+    end
+  end
+end
+```
+
+### A has one relation to a model called Or
+If you happen to have a model/table named 'Or' then you can override the `or:` key syntax by specifying a special `or_key`:-
+
+```ruby
+class AuthorFilter
+  include Rokaki::FilterModel
+
+  or_key :my_or
+  filter_map :author, :query,
+    like: {
+      articles: {
+        title: :circumfix,
+        my_or: { # the or is aware of the join and will generate a compound join aware or query
+          or: { # The Or model has a title field
+            title: :circumfix
+          }
+        }
+      },
+    }
+
+  attr_accessor :filters, :model
+
+  def initialize(filters:)
+    @filters = filters
+  end
+end
+
+filters = { query: "Syntaxes" }
+filtered_authors = AuthorFilter.new(filters: filters).results
+```
+
+
+See [this issue](https://github.com/rails/rails/issues/24055) for details.
+
+
 #### 3. The porcelain command syntax
 
 In this syntax you will need to provide three keywords:- `filters`, `like` and `filter_model` if you are not passing in the model type and assigning it to `@model`

data/lib/rokaki.rb

@@ -3,13 +3,12 @@
 require 'rokaki/version'
 require 'rokaki/filterable'
 require 'rokaki/filter_model'
+require 'rokaki/filter_model/join_map'
 require 'rokaki/filter_model/like_keys'
 require 'rokaki/filter_model/basic_filter'
 require 'rokaki/filter_model/nested_filter'
+require 'rokaki/filter_model/nested_like_filters'
 
 module Rokaki
   class Error < StandardError; end
-
-  # include this module for filters dsl in an object
-  #
 end

data/lib/rokaki/filter_model.rb

@@ -8,7 +8,7 @@ module Rokaki
     end
 
     def prepare_terms(param, mode)
-      if param.is_a? Array
+      if Array === param
         return param.map { |term| "%#{term}%" } if mode == :circumfix
         return param.map { |term| "%#{term}" } if mode == :prefix
         return param.map { |term| "#{term}%" } if mode == :suffix
@@ -27,9 +27,10 @@ module Rokaki
 
       def filter_map(model, query_key, options)
         filter_model(model)
-        @_query_key = query_key
+        @filter_map_query_key = query_key
 
         @_filter_db = options[:db] || :postgres
+        @_filter_mode = options[:mode] || :and
         like(options[:like]) if options[:like]
         ilike(options[:ilike]) if options[:ilike]
         filters(*options[:match]) if options[:match]
@@ -37,34 +38,57 @@ module Rokaki
 
       def filter(model, options)
         filter_model(model)
+        @filter_map_query_key = nil
 
         @_filter_db = options[:db] || :postgres
+        @_filter_mode = options[:mode] || :and
         like(options[:like]) if options[:like]
         ilike(options[:ilike]) if options[:ilike]
         filters(*options[:match]) if options[:match]
       end
 
       def filters(*filter_keys)
-        if @_query_key
-          define_filter_map(@_query_key, *filter_keys)
+        if @filter_map_query_key
+          define_filter_map(@filter_map_query_key, *filter_keys)
         else
           define_filter_keys(*filter_keys)
         end
 
         @_chain_filters ||= []
         filter_keys.each do |filter_key|
-
           # TODO: does the key need casting to an array here?
           _chain_filter(filter_key) unless filter_key.is_a? Hash
-
           _chain_nested_filter(filter_key) if filter_key.is_a? Hash
+        end
+
+        define_results # writes out all the generated filters
+      end
 
+      def like_filters(like_keys, term_type: :like)
+        if @filter_map_query_key
+          define_filter_map(@filter_map_query_key, *like_keys.call)
+        else
+          define_filter_keys(*like_keys.call)
         end
 
+        @_chain_filters ||= []
+        filter_map = []
+
+        nested_like_filter = NestedLikeFilters.new(
+          filter_key_object: like_keys,
+          prefix: filter_key_prefix,
+          infix: filter_key_infix,
+          db: @_filter_db,
+          type: term_type,
+          or_key: or_key
+        )
+        nested_like_filter.call
+
+        _chain_nested_like_filter(nested_like_filter)
         define_results # writes out all the generated filters
       end
 
-      def _chain_filter(key)
+      def _build_basic_filter(key)
         basic_filter = BasicFilter.new(
           keys: [key],
           prefix: filter_key_prefix,
@@ -74,13 +98,17 @@ module Rokaki
           db: @_filter_db
         )
         basic_filter.call
+        basic_filter
+      end
 
+      def _chain_filter(key)
+        basic_filter = _build_basic_filter(key)
         class_eval basic_filter.filter_method, __FILE__, __LINE__ - 2
 
         @_chain_filters << basic_filter.filter_template
       end
 
-      def _chain_nested_filter(filters_object)
+      def _build_nested_filter(filters_object)
         nested_filter = NestedFilter.new(
           filter_key_object: filters_object,
           prefix: filter_key_prefix,
@@ -90,18 +118,29 @@ module Rokaki
           db: @_filter_db
         )
         nested_filter.call
+        nested_filter
+      end
 
-        nested_filter.filter_methods.each do |filter_method|
+      def _chain_nested_like_filter(filters_object)
+        filters_object.filter_methods.each do |filter_method|
           class_eval filter_method, __FILE__, __LINE__ - 2
         end
 
-        nested_filter.filter_templates.each do |filter_template|
+        filters_object.templates.each do |filter_template|
           @_chain_filters << filter_template
         end
       end
 
-      def associated_table(association)
-        @model.reflect_on_association(association).klass.table_name
+      def _chain_nested_filter(filters_object)
+        nested_filter = _build_nested_filter(filters_object)
+
+        nested_filter.filter_methods.each do |filter_method|
+          class_eval filter_method, __FILE__, __LINE__ - 2
+        end
+
+        nested_filter.filter_templates.each do |filter_template|
+          @_chain_filters << filter_template
+        end
       end
 
       def filter_model(model_class)
@@ -113,41 +152,16 @@ module Rokaki
         raise ArgumentError, 'argument mush be a hash' unless args.is_a? Hash
         @_like_semantics = (@_like_semantics || {}).merge(args)
 
-        key_builder = LikeKeys.new(args)
-        keys = key_builder.call
-
-        filters(*keys)
+        like_keys = LikeKeys.new(args)
+        like_filters(like_keys, term_type: :like)
       end
 
       def ilike(args)
         raise ArgumentError, 'argument mush be a hash' unless args.is_a? Hash
         @i_like_semantics = (@i_like_semantics || {}).merge(args)
 
-        key_builder = LikeKeys.new(args)
-        keys = key_builder.call
-
-        filters(*keys)
-      end
-
-      def deep_chain(keys, value)
-        if value.is_a? Hash
-          value.keys.map do |key|
-            _keys = keys.dup << key
-            deep_chain(_keys, value[key])
-          end
-        end
-
-        if value.is_a? Array
-          value.each do |av|
-            _keys = keys.dup << av
-            _build_deep_chain(_keys)
-          end
-        end
-
-        if value.is_a? Symbol
-          _keys = keys.dup << value
-          _build_deep_chain(_keys)
-        end
+        like_keys = LikeKeys.new(args)
+        like_filters(like_keys, term_type: :ilike)
       end
 
       # the model method is called to instatiate @model from the

data/lib/rokaki/filter_model/basic_filter.rb

@@ -10,8 +10,9 @@ module Rokaki
         @like_semantics = like_semantics
         @i_like_semantics = i_like_semantics
         @db = db
+        @filter_query = nil
       end
-      attr_reader :keys, :prefix, :infix, :like_semantics, :i_like_semantics, :db
+      attr_reader :keys, :prefix, :infix, :like_semantics, :i_like_semantics, :db, :filter_query
       attr_accessor :filter_method, :filter_template
 
       def call
@@ -56,7 +57,7 @@ module Rokaki
           query = "@model.where(#{key}: #{filter})"
         end
 
-        query
+        @filter_query = query
       end
 
       def build_like_query(type:, query:, filter:, mode:, key:)

data/lib/rokaki/filter_model/deep_assign_struct.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Rokaki
+  module FilterModel
+    class DeepAssignStruct
+      def initialize(keys:, value:, struct: nil)
+        @keys = keys
+        @value = value
+        @struct = struct
+      end
+      attr_reader :keys, :value
+      attr_accessor :struct
+
+      def call
+        base_keys = keys
+        i = base_keys.length - 1
+
+        base_keys.reverse_each.reduce (value) do |struc,key|
+          i -= 1
+          cur_keys = base_keys[0..i]
+
+          if struct
+            val = struct.dig(*cur_keys)
+            val[key] = struc
+            p val
+            return val
+          else
+            if key.is_a?(Integer)
+              struct = [struc]
+            else
+              { key=>struc }
+            end
+          end
+        end
+      end
+
+      private
+
+      def deep_construct(keys, value)
+
+        if keys.last.is_a?(Integer)
+          rstruct = struct[keys.last] = value
+        else
+          rstruct = { keys.last => value }
+        end
+
+        keys[0..-2].reverse_each.reduce (rstruct) do |struc,key|
+          if key.is_a?(Integer)
+            [struc]
+          else
+            { key=>struc }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rokaki/filter_model/join_map.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# DOUBLE SPLAT HASHES TO MAKE ARG LISTS!
+#
+# Array#dig could be useful
+#
+# Array#intersection could be useful
+#
+# Array#difference could be useful
+#
+
+module Rokaki
+  module FilterModel
+    class JoinMap
+      def initialize(key_paths)
+        @key_paths = key_paths
+        @result = {}
+      end
+
+      attr_reader :key_paths
+      attr_accessor :result
+
+      def call
+        key_paths.uniq.each do |key_path|
+          current_key_path = []
+          previous_key = nil
+
+          if Symbol === key_path
+            if key_paths.length == 1
+              @result = key_paths
+            else
+              result[key_path] = {} unless result.keys.include? key_path
+            end
+          end
+
+          if Array === key_path
+            key_path.each do |key|
+              current_path_length = current_key_path.length
+
+              if current_path_length > 0 && result.dig(current_key_path).nil?
+
+                if current_path_length == 1
+                  parent_result = result[previous_key]
+
+                  if Symbol === parent_result && parent_result != key
+                    result[previous_key] = [parent_result, key]
+                  elsif Array === parent_result
+
+                    parent_result.each_with_index do |array_item, index|
+                      if array_item == key
+                        current_key_path << index
+                      end
+                    end
+
+                  else
+                    result[previous_key] = key unless result[previous_key] == key
+                  end
+
+                else
+                  previous_key_path = current_key_path - [previous_key]
+                  previous_path_length = previous_key_path.length
+                  p current_key_path
+
+                  if previous_path_length == 1
+                    res = result.dig(*previous_key_path)
+
+                    if Symbol === res
+                      result[previous_key_path.first] = { previous_key => key }
+                    end
+                  elsif previous_path_length > 1
+                    res = result.dig(*previous_key_path)
+
+                    if Symbol === res
+                      base = previous_key_path.pop
+                      result.dig(*previous_key_path)[base] = { previous_key => key }
+                    end
+                  end
+
+                end
+              else
+              end
+
+              previous_key = key
+              current_key_path << key
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/rokaki/filter_model/like_keys.rb

@@ -9,43 +9,45 @@ module Rokaki
     class LikeKeys
       def initialize(args)
         @args = args
-        @like_keys = []
+        @keys = []
+        @key_paths = []
       end
 
-      attr_reader :args, :like_keys
+      attr_reader :args, :keys, :key_paths
 
       def call
         args.keys.each do |key|
-          like_keys << map_keys(args[key], key)
+          map_keys(key: key, value: args[key])
         end
-        like_keys
+        keys
       end
 
       private
 
-      def map_keys(value, key)
-        key_result = {}
+      def map_keys(key:, value:, key_path: [])
 
-        if value.is_a? Hash
-        value.keys.each do |sub_key|
-          sub_value = value[sub_key]
-
-          if sub_value.is_a? Symbol
-            if key_result[key].is_a? Array
-              key_result[key] << sub_key
-            else
-              key_result[key] = [ sub_key ]
-            end
-
-          elsif sub_value.is_a? Hash
-            key_result[key] = map_keys(sub_value, sub_key)
+        if value.is_a?(Hash)
+          key_path << key
+          value.keys.each do |key|
+            map_keys(key: key, value: value[key], key_path: key_path.dup)
           end
         end
-        else
-          key_result = key
+
+        if value.is_a?(Symbol)
+          keys << (key_path.empty? ? key : deep_assign(key_path, key))
+          key_path << key
+          key_paths << key_path
         end
 
-        key_result
+        key_path
+
+      end
+
+      # Many thanks Cary Swoveland
+      # https://stackoverflow.com/questions/56634950/ruby-dig-set-assign-values-using-hashdig/56635124
+      #
+      def deep_assign(keys, value)
+        keys[0..-2].reverse_each.reduce ({ keys.last => value }) { |h,key| { key=>h } }
       end
     end
   end

data/lib/rokaki/filter_model/nested_filter.rb

@@ -4,7 +4,7 @@ require 'active_support/inflector'
 module Rokaki
   module FilterModel
     class NestedFilter
-      def initialize(filter_key_object:, prefix:, infix:, like_semantics:, i_like_semantics:, db:)
+      def initialize(filter_key_object:, prefix:, infix:, like_semantics:, i_like_semantics:, db:, mode: :and)
         @filter_key_object = filter_key_object
         @prefix = prefix
         @infix = infix
@@ -13,8 +13,9 @@ module Rokaki
         @filter_methods = []
         @filter_templates = []
         @db = db
+        @mode = mode
       end
-      attr_reader :filter_key_object, :prefix, :infix, :like_semantics, :i_like_semantics, :db
+      attr_reader :filter_key_object, :prefix, :infix, :like_semantics, :i_like_semantics, :db, :mode
       attr_accessor :filter_methods, :filter_templates
 
       def call # _chain_nested_filter
@@ -56,7 +57,7 @@ module Rokaki
       end
 
       def find_i_like_key(keys)
-        return nil unless like_semantics && i_like_semantics.keys.any?
+        return nil unless i_like_semantics && i_like_semantics.keys.any?
         current_like_key = i_like_semantics
         keys.each do |key|
           current_like_key = current_like_key[key]
@@ -65,7 +66,7 @@ module Rokaki
       end
 
       def _build_deep_chain(keys)
-        name    = '' # prefix.to_s
+        name    = ''
         count   = keys.size - 1
 
         joins_before = []
@@ -74,13 +75,13 @@ module Rokaki
         where_before = []
         where_after = []
         out   = ''
-        mode = nil
+        search_mode = nil
         type = nil
         leaf = nil
 
-        if mode = find_like_key(keys)
+        if search_mode = find_like_key(keys)
           type = 'LIKE'
-        elsif mode = find_i_like_key(keys)
+        elsif search_mode = find_i_like_key(keys)
           type = 'ILIKE'
         end
         leaf = keys.pop
@@ -113,12 +114,12 @@ module Rokaki
         joins = joins.join
         where = where.join
 
-        if mode
+        if search_mode
           query = build_like_query(
             type: type,
             query: '',
             filter: "#{prefix}#{name}",
-            mode: mode,
+            search_mode: search_mode,
             key: keys.last.to_s.pluralize,
             leaf: leaf
           )
@@ -135,15 +136,15 @@ module Rokaki
         end
       end
 
-      def build_like_query(type:, query:, filter:, mode:, key:, leaf:)
+      def build_like_query(type:, query:, filter:, search_mode:, key:, leaf:)
         if db == :postgres
           query = "where(\"#{key}.#{leaf} #{type} ANY (ARRAY[?])\", "
-          query += "prepare_terms(#{filter}, :#{mode}))"
+          query += "prepare_terms(#{filter}, :#{search_mode}))"
         else
           query = "where(\"#{key}.#{leaf} #{type} :query\", "
-          query += "query: \"%\#{#{filter}}%\")" if mode == :circumfix
-          query += "query: \"%\#{#{filter}}\")" if mode == :prefix
-          query += "query: \"\#{#{filter}}%\")" if mode == :suffix
+          query += "query: \"%\#{#{filter}}%\")" if search_mode == :circumfix
+          query += "query: \"%\#{#{filter}}\")" if search_mode == :prefix
+          query += "query: \"\#{#{filter}}%\")" if search_mode == :suffix
         end
 
         query

data/lib/rokaki/filter_model/nested_like_filters.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+require 'active_support/inflector'
+
+module Rokaki
+  module FilterModel
+    class NestedLikeFilters
+      def initialize(filter_key_object:, prefix:, infix:, db:, mode: :and, or_key: :or, type: :like)
+        @filter_key_object = filter_key_object
+        @prefix = prefix
+        @infix = infix
+        @db = db
+        @mode = mode
+        @or_key = or_key
+        @type = type
+
+        @names = []
+        @filter_methods = []
+        @templates = []
+        @filter_queries = []
+        @method_names = []
+        @filter_names = []
+        @join_key_paths = []
+        @key_paths = []
+        @search_modes = []
+        @modes = []
+      end
+      attr_reader :filter_key_object, :prefix, :infix, :like_semantics, :i_like_semantics,
+        :db, :mode, :or_key, :filter_queries, :type
+      attr_accessor :filter_methods, :templates, :method_names, :filter_names, :names, :join_key_paths, :key_paths, :search_modes, :modes
+
+      def call
+        build_filters_data
+        compound_filters
+      end
+
+      def build_filters_data
+        results = filter_key_object.key_paths.each do |key_path|
+          if key_path.is_a?(Symbol)
+            build_filter_data(key_path)
+          else
+            if key_path.include? or_key
+              build_filter_data(key_path.dup, mode: or_key)
+            else
+              build_filter_data(key_path.dup)
+            end
+          end
+        end
+      end
+
+      def compound_filters
+        # key_paths represents a structure like
+        # [
+        #   [ # this is an or
+        #     [:articles, :title],
+        #     [:articles, :authors, :first_name],
+        #     [:articles, :authors, :reviews, :title],
+        #     [:articles, :authors, :reviews, :content]
+        #   ],
+        #   [:articles, :content] # this is an and
+        # ]
+        #
+        # Each item in the array represents a compounded filter
+        #
+        key_paths.each_with_index do |key_path_item, index|
+          base_names = get_name(index)
+          join_map = JoinMap.new(join_key_paths[index])
+          join_map.call
+
+          if key_path_item.first.is_a?(Array)
+            item_search_modes = search_modes[index]
+
+            base_name = base_names.shift
+            method_name = prefix.to_s + ([:filter].push base_name).compact.join(infix.to_s)
+            method_name += (infix.to_s+'or'+infix.to_s) + (base_names).join(infix.to_s+'or'+infix.to_s)
+            item_filter_names = [prefix.to_s + base_name]
+
+            base_names.each do |filter_base_name|
+              item_filter_names << (prefix.to_s + filter_base_name)
+            end
+
+            base_modes = modes[index]
+            key_path_item.each_with_index do |key_path, kp_index|
+
+              build_query(keys: key_path.dup, join_map: join_map.result, mode: base_modes[kp_index], filter_name: item_filter_names[kp_index], search_mode: item_search_modes[kp_index])
+            end
+
+            item_filter_queries = filter_queries[index]
+            first_query = item_filter_queries.shift
+
+            ored = item_filter_queries.map do |query|
+              ".or(#{query})"
+            end
+
+            filter_conditions = item_filter_names.join(' || ')
+
+            @filter_methods << "def #{method_name}; #{first_query + ored.join}; end;"
+            @templates << "@model = #{method_name} if #{filter_conditions};"
+          else
+
+            base_name = get_name(index)
+            filter_name = "#{prefix}#{get_filter_name(index)}"
+
+            method_name = ([prefix, :filter, base_name]).compact.join(infix.to_s)
+
+            build_query(keys: key_path_item.dup, join_map: join_map.result, filter_name: filter_name, search_mode: search_modes[index])
+
+            @filter_methods << "def #{method_name}; #{filter_queries[index]}; end;"
+            @templates << "@model = #{method_name} if #{filter_name};"
+          end
+        end
+      end
+
+      private
+
+      def get_name(index)
+        names[index]
+      end
+
+      def get_filter_name(index)
+        filter_names[index]
+      end
+
+      def find_mode_key(keys)
+        current_like_key = @filter_key_object.args.dup
+        keys.each do |key|
+          current_like_key = current_like_key[key]
+        end
+        current_like_key
+      end
+
+      def build_filter_data(key_path, mode: :and)
+        # if key_path.is_a?(Symbol)
+        #   search_mode = @filter_key_object.args[key_path]
+
+        #   name = key_path
+        #   filter_name = (prefix.to_s + key_path.to_s)
+        #   @names << name
+        #   @filter_names << filter_name
+        #   @key_paths << key_path
+        #   @search_modes << search_mode
+        #   @modes << mode
+        # else
+          search_mode = find_mode_key(key_path)
+
+          key_path.delete(mode)
+
+          name = key_path.join(infix.to_s)
+          filter_name = key_path.compact.join(infix.to_s)
+
+          if mode == or_key
+            @names << [@names.pop, name].flatten
+            @filter_names << [@filter_names.pop, filter_name].flatten
+
+            or_key_paths = @key_paths.pop
+            if or_key_paths.first.is_a?(Array)
+              @key_paths <<  [*or_key_paths] + [key_path.dup]
+            else
+              @key_paths <<  [or_key_paths] + [key_path.dup]
+            end
+
+            @search_modes << [@search_modes.pop, search_mode].flatten
+            @modes << [@modes.pop, mode].flatten
+
+          else
+            @names << name
+            @filter_names << filter_name
+            @key_paths << key_path.dup # having this wrapped in an array is messy for single items
+            @search_modes << search_mode
+            @modes << mode
+          end
+
+          join_key_path = key_path.dup
+
+          leaf = join_key_path.pop
+          if mode == or_key
+            or_join_key_paths = @join_key_paths.pop
+            if or_join_key_paths.first.is_a?(Array)
+              @join_key_paths <<  [*or_join_key_paths] + [join_key_path.dup]
+            else
+              @join_key_paths <<  [or_join_key_paths] + [join_key_path.dup]
+            end
+          else
+            if join_key_path.length == 1
+              @join_key_paths << join_key_path
+            else
+              @join_key_paths << [join_key_path.dup]
+            end
+          end
+        # end
+      end
+
+      # DOUBLE SPLAT HASHES TO MAKE ARG LISTS!
+      def build_query(keys: , join_map:, mode: :and, filter_name:, search_mode:)
+        leaf = nil
+        leaf = keys.pop
+
+
+        query = build_like_query(
+          type: type,
+          query: '',
+          filter: filter_name,
+          search_mode: search_mode,
+          key: keys.last,
+          leaf: leaf
+        )
+
+        if join_map.empty?
+          filter_query = "@model.#{query}"
+        elsif join_map.is_a?(Array)
+          filter_query = "@model.joins(*#{join_map}).#{query}"
+        else
+          filter_query = "@model.joins(**#{join_map}).#{query}"
+        end
+
+        if mode == or_key
+          @filter_queries << [@filter_queries.pop, filter_query].flatten
+        else
+          @filter_queries << filter_query
+        end
+        filter_query
+      end
+
+      def build_like_query(type:, query:, filter:, search_mode:, key:, leaf:)
+        key_leaf = key ? "#{key.to_s.pluralize}.#{leaf}" : leaf
+        if db == :postgres
+          query = "where(\"#{key_leaf} #{type.to_s.upcase} ANY (ARRAY[?])\", "
+          query += "prepare_terms(#{filter}, :#{search_mode}))"
+        else
+          query = "where(\"#{key_leaf} #{type.to_s.upcase} :query\", "
+          query += "query: \"%\#{#{filter}}%\")" if search_mode == :circumfix
+          query += "query: \"%\#{#{filter}}\")" if search_mode == :prefix
+          query += "query: \"\#{#{filter}}%\")" if search_mode == :suffix
+        end
+
+        query
+      end
+
+    end
+  end
+end
+

data/lib/rokaki/filterable.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module Rokaki
+  # include this module for rokaki's filtering dsl in any object
+  #
   module Filterable
     def self.included(base)
       base.extend(ClassMethods)
@@ -11,18 +15,22 @@ module Rokaki
 
       def define_filter_keys(*filter_keys)
         filter_keys.each do |filter_key|
-          _build_filter([filter_key]) unless filter_key.is_a? Hash
-          _nested_key filter_key if filter_key.is_a? Hash
+          _build_filter([filter_key]) unless Hash === filter_key
+          _nested_key filter_key if Hash === filter_key
         end
       end
 
       def define_filter_map(query_field, *filter_keys)
         filter_keys.each do |filter_key|
-          _map_filters(query_field, [filter_key]) unless filter_key.is_a? Hash
-          _nested_map query_field, filter_key if filter_key.is_a? Hash
+          _map_filters(query_field, [filter_key]) unless Hash === filter_key
+          _nested_map query_field, filter_key if Hash === filter_key
         end
       end
 
+      def define_query_key(key = nil)
+        @filter_map_query_key = key
+      end
+
       def filter_key_prefix(prefix = nil)
         @filter_key_prefix ||= prefix
       end
@@ -31,11 +39,16 @@ module Rokaki
         @filter_key_infix ||= infix
       end
 
+      def or_key(or_key = :or)
+        @or_key ||= or_key
+      end
+
       def filterable_object_name(name = 'filters')
         @filterable_object_name ||= name
       end
 
       def _build_filter(keys)
+        keys.delete(or_key)
         name    = @filter_key_prefix.to_s
         count   = keys.size - 1
 
@@ -48,6 +61,7 @@ module Rokaki
       end
 
       def _map_filters(query_field, keys)
+        keys.delete(or_key)
         name    = @filter_key_prefix.to_s
         count   = keys.size - 1
 

data/lib/rokaki/version.rb

@@ -1,3 +1,3 @@
 module Rokaki
-  VERSION = "0.8.1"
+  VERSION = "0.8.3.1"
 end

data/rokaki.gemspec

@@ -34,13 +34,17 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'activerecord'
   spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'factory_bot'
-  spec.add_development_dependency 'guard'
-  spec.add_development_dependency 'guard-rspec'
-  spec.add_development_dependency 'pg'
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'pry-byebug'
   spec.add_development_dependency 'rake', '~> 13.0'
+
+  spec.add_development_dependency 'guard'
+  spec.add_development_dependency 'guard-rspec'
   spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'factory_bot'
+
+  spec.add_development_dependency 'pg'
   spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'database_cleaner-active_record'
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rokaki
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.3.1
 platform: ruby
 authors:
 - Steve Martin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-21 00:00:00.000000000 Z
+date: 2020-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: factory_bot
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: guard
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,21 +81,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: guard-rspec
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: guard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -123,7 +123,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -137,35 +151,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: database_cleaner-active_record
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -200,9 +214,12 @@ files:
 - lib/rokaki.rb
 - lib/rokaki/filter_model.rb
 - lib/rokaki/filter_model/basic_filter.rb
+- lib/rokaki/filter_model/deep_assign_struct.rb
 - lib/rokaki/filter_model/filter_chain.rb
+- lib/rokaki/filter_model/join_map.rb
 - lib/rokaki/filter_model/like_keys.rb
 - lib/rokaki/filter_model/nested_filter.rb
+- lib/rokaki/filter_model/nested_like_filters.rb
 - lib/rokaki/filterable.rb
 - lib/rokaki/version.rb
 - rokaki.gemspec