rokaki 0.8.2 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5484d6a4935bbc4f908e9081c82fcfd757f2e49770b7cbde2c055ec9ab169b0
-  data.tar.gz: 44a41e6c4ba814bc98934ddb2029a222841fd18425847c73ab3a9a3d86acc66a
+  metadata.gz: 53402d2c7b2fca689234d8bed13602eef1bac7a161b09fe15da517da8939e5ac
+  data.tar.gz: 2a903781f7d5f2e4b90c419def1dc5a2b8289798a708a66e6be91604de02de86
 SHA512:
-  metadata.gz: e8c29246d64a0fc0c5ca63173c419cee77cf07cd06d99a1fc14bcc53285222d980e8ace9e624bb75d4566814bfc8ce38613305676d2152591da83f8ea04002b1
-  data.tar.gz: 82ac3f4b16473b8adf6aeeb93907a0e71ab811c439d5071e95b063238042828c39818f33763a953fa0898c40c0d0f912cc6b3781b9ff1bb75d6c3227c8efd282
+  metadata.gz: 7cd1957fe50f484e465a7c592a6e770e6a0e46975479ea4863deab66434031936d477b852ae8b72095943bc0db47d1379cd089b280485f5d4a7aa90d50cc6a12
+  data.tar.gz: 9b966c7cafd777655fcb6f20b70b3c331d2f8175c8bf22c49ef4295188f25ae15a7b8581738f4fbac5eb5e605b129088936c8588097015d366080b8866687891

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rokaki (0.8.2)
+    rokaki (0.8.3)
       activesupport
 
 GEM

data/README.md

@@ -227,6 +227,36 @@ 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
+```
+
 #### 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,9 +3,11 @@
 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

data/lib/rokaki/filter_model.rb

@@ -30,6 +30,7 @@ module Rokaki
         @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]
@@ -40,6 +41,7 @@ module Rokaki
         @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]
@@ -54,18 +56,38 @@ module Rokaki
 
         @_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
+        )
+        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,
@@ -75,13 +97,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,
@@ -91,6 +117,21 @@ module Rokaki
           db: @_filter_db
         )
         nested_filter.call
+        nested_filter
+      end
+
+      def _chain_nested_like_filter(filters_object)
+        filters_object.filter_methods.each do |filter_method|
+          class_eval filter_method, __FILE__, __LINE__ - 2
+        end
+
+        filters_object.templates.each do |filter_template|
+          @_chain_filters << filter_template
+        end
+      end
+
+      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
@@ -101,10 +142,6 @@ module Rokaki
         end
       end
 
-      # def associated_table(association)
-      #   @model.reflect_on_association(association).klass.table_name
-      # end
-
       def filter_model(model_class)
         @model = (model_class.is_a?(Class) ? model_class : Object.const_get(model_class.capitalize))
         class_eval "def set_model; @model ||= #{@model}; end;"
@@ -114,41 +151,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,104 @@
+# 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 key_path.is_a?(Symbol)
+            if key_paths.length == 1
+              @result = key_paths
+            else
+              result[key_path] = {} unless result.keys.include? key_path
+            end
+          end
+
+          if key_path.is_a?(Array)
+            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 parent_result.is_a?(Symbol) && parent_result != key
+                    result[previous_key] = [parent_result, key]
+                  elsif parent_result.is_a?(Array)
+
+                    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 res.is_a? Symbol
+                      result[previous_key_path.first] = { previous_key => key }
+                    elsif res.is_a?(Hash)
+                    end
+                  elsif previous_path_length > 1
+                    res = result.dig(*previous_key_path)
+                    if res.is_a? Symbol
+                      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,45 +9,38 @@ 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|
-          map_keys(args[key], key)
+          map_keys(key: key, value: args[key])
         end
-        like_keys
+        keys
       end
 
       private
 
-      def map_keys(value, key, key_path = [])
-        key_result = {}
-        key_path << key
+      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 ]
-              @like_keys << deep_assign(key_path, key_result[key])
-            end
-
-          elsif sub_value.is_a? Hash
-            map_keys(sub_value, sub_key, key_path)
+        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
-          @like_keys = [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

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
@@ -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_filter(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_filter(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_filter(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
+          @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

@@ -35,11 +35,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
 
@@ -52,6 +57,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.2"
+  VERSION = "0.8.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rokaki
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.8.3
 platform: ruby
 authors:
 - Steve Martin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-22 00:00:00.000000000 Z
+date: 2020-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -200,9 +200,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