rokaki 0.6.0 → 0.8.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7da479ed93b1e8e6aa8e91e080356e71b39061a647960175c49ef0f5a1b90855
-  data.tar.gz: 021aaa044351b96fec1566c1e900f816908cc9a7dcd53d7d8b2a547e7d120872
+  metadata.gz: 44e54fda626422f9ed27d25aa30aa7f6303722a16b0bb931b6aeead9965b380f
+  data.tar.gz: 2b5a2ea0ce4284e84fcf006071b5831e41df8dfbd83399be23fd62f2cae7ad9c
 SHA512:
-  metadata.gz: 6f4b5be13f85b953aced1c4269539d5abe5c2611a22bbc3fdda2c19c8254e872116b51ec235e856015e0574f8439d761d3eb433c6f94499683590084814b560d
-  data.tar.gz: fb29f358eca0b1186afd6cb1417538bac16731a8a2c1faf06c9526afd7e00bc93bcbdfd642b1a8912b02fbe39318842e8730a738586e64ed5df5d7915e94a6b2
+  metadata.gz: '039a420452518968761d8eff610603a643825fa98de17d51cb038f6fcd79f4870b898688c5bbc6fc61a193ccc21a6cd86b7a50027aa6219520fa1cd3b25469d6'
+  data.tar.gz: 5c69385b228a28f6378b2c8a4e584e597c6e80b5781b634fd8ca977e16f67d65c64c4ca16a1f6ff2bfe6c0cd3a55410033eabe2ac8f195fc46d23cba2ac7c624

data/.gitignore

@@ -10,3 +10,4 @@
 # rspec failure tracking
 .rspec_status
 tags
+*.gem

data/Gemfile.lock

@@ -1,30 +1,32 @@
 PATH
   remote: .
   specs:
-    rokaki (0.5.1)
+    rokaki (0.8.1)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.0.0)
-      activesupport (= 6.0.0)
-    activerecord (6.0.0)
-      activemodel (= 6.0.0)
-      activesupport (= 6.0.0)
-    activesupport (6.0.0)
+    activemodel (6.0.3.2)
+      activesupport (= 6.0.3.2)
+    activerecord (6.0.3.2)
+      activemodel (= 6.0.3.2)
+      activesupport (= 6.0.3.2)
+    activesupport (6.0.3.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-      zeitwerk (~> 2.1, >= 2.1.8)
-    byebug (11.0.1)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.6)
     diff-lcs (1.3)
-    ffi (1.11.1)
+    factory_bot (6.0.2)
+      activesupport (>= 5.0.0)
+    ffi (1.13.1)
     formatador (0.2.5)
-    guard (2.15.0)
+    guard (2.16.2)
       formatador (>= 0.2.4)
       listen (>= 2.7, < 4.0)
       lumberjack (>= 1.0.12, < 2.0)
@@ -38,50 +40,49 @@ GEM
       guard (~> 2.1)
       guard-compat (~> 1.1)
       rspec (>= 2.99.0, < 4.0)
-    i18n (1.6.0)
+    i18n (1.8.3)
       concurrent-ruby (~> 1.0)
-    listen (3.1.5)
-      rb-fsevent (~> 0.9, >= 0.9.4)
-      rb-inotify (~> 0.9, >= 0.9.7)
-      ruby_dep (~> 1.2)
-    lumberjack (1.0.13)
-    method_source (0.9.2)
-    minitest (5.11.3)
+    listen (3.2.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    lumberjack (1.2.6)
+    method_source (1.0.0)
+    minitest (5.14.1)
     nenv (0.3.0)
     notiffany (0.1.3)
       nenv (~> 0.1)
       shellany (~> 0.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    pry-byebug (3.7.0)
+    pg (1.2.3)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
       byebug (~> 11.0)
-      pry (~> 0.10)
-    rake (10.5.0)
-    rb-fsevent (0.10.3)
-    rb-inotify (0.10.0)
+      pry (~> 0.13.0)
+    rake (13.0.1)
+    rb-fsevent (0.10.4)
+    rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.2)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
-    ruby_dep (1.5.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
     shellany (0.0.1)
-    sqlite3 (1.4.1)
-    thor (0.20.3)
+    sqlite3 (1.4.2)
+    thor (1.0.1)
     thread_safe (0.3.6)
-    tzinfo (1.2.5)
+    tzinfo (1.2.7)
       thread_safe (~> 0.1)
-    zeitwerk (2.1.9)
+    zeitwerk (2.3.0)
 
 PLATFORMS
   ruby
@@ -89,14 +90,16 @@ PLATFORMS
 DEPENDENCIES
   activerecord
   bundler (~> 2.0)
+  factory_bot
   guard
   guard-rspec
+  pg
   pry
   pry-byebug
-  rake (~> 10.0)
+  rake (~> 13.0)
   rokaki!
   rspec (~> 3.0)
   sqlite3
 
 BUNDLED WITH
-   2.0.2
+   2.1.4

data/README.md

@@ -1,14 +1,19 @@
 # Rokaki
 [![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 or any ruby app that uses the concept of `filters`.
-
-It's a simple gem that just provides you with a basic dsl based on the filter params that you might pass through from a web request.
+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".
 
+There are two modes of use `Filterable` and `FilterModel` that can be activated through the use of two mixins respectively, `include Rokaki::Filterable` or `include Rokaki::FilterModel`.
 ## Installation
 
 Add this line to your application's Gemfile:
 
+You can install from Rubygems:
+```
+gem 'rokaki'
+```
+Or from github
+
 ```ruby
 gem 'rokaki', git: 'https://github.com/tevio/rokaki.git'
 ```
@@ -17,42 +22,118 @@ And then execute:
 
     $ bundle
 
-## Usage
+## `Rokaki::Filterable` - Usage
+
+To use the DSL first include the `Rokaki::Filterable` module in your [por](http://blog.jayfields.com/2007/10/ruby-poro.html) class.
 
-To use the basic DSL include the `Rokaki::Filterable` module
+### `#define_filter_keys`
+#### A Simple Example
 
 A simple example might be:-
 
 ```ruby
-  class FilterArticles
-    include Rokaki::Filterable
+class FilterArticles
+  include Rokaki::Filterable
 
-    def initialize(filters:)
-      @filters = filters
-      @articles = Article
-    end
+  def initialize(filters:)
+    @filters = filters
+    @articles = Article
+  end
 
-    attr_accessor :filters
+  attr_accessor :filters
 
-    define_filter_keys :date, author: [:first_name, :last_name]
+  define_filter_keys :date, author: [:first_name, :last_name]
 
-    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
-    end
+  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
   end
+end
+
+article_filter = FilterArticles.new(filters: {
+  date: '10-10-10',
+  author: {
+    first_name: 'Steve',
+    last_name: 'Martin'
+  }})
+article_filter.author_first_name == 'Steve'
+article_filter.author_last_name == 'Martin'
+article_filter.date == '10-10-10'
+```
+
+In this example Rokaki maps the "flat" attribute "keys" `date`, `author_first_name` and `author_last_name` to a `@filters` object with the expected deep structure `{ date: '10-10-10', author: { first_name: 'Steve' } }`, to make it simple to use them in filter queries.
+
+#### A More Complex Example
+
+```ruby
+class AdvancedFilterable
+  include Rokaki::Filterable
+
+  def initialize(filters:)
+    @fyltrz = filters
+  end
+  attr_accessor :fyltrz
+
+  filterable_object_name :fyltrz
+  filter_key_infix :__
+  define_filter_keys :basic, advanced: {
+    filter_key_1: [:filter_key_2, { filter_key_3: :deep_node }],
+    filter_key_4: :deep_leaf_array
+  }
+end
+
+
+advanced_filterable = AdvancedFilterable.new(filters: {
+  basic: 'ABC',
+  advanced: {
+    filter_key_1: {
+      filter_key_2: '123',
+      filter_key_3: { deep_node: 'NODE' }
+    },
+    filter_key_4: { deep_leaf_array: [1,2,3,4] }
+  }
+})
+
+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`
 
-This maps attributes `date`, `author_first_name` and `author_last_name` to a filters object with the structure `{ date: '10-10-10', author: { first_name: 'Shteeve' } }`.
+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.
 
-## Additional options
-You can specify a `filter_key_prefix` and a `filter_key_infix` to change the structure of the accessors.
+#### A Simple Example
+```ruby
+class FilterMap
+  include Rokaki::Filterable
+
+  def initialize(fylterz:)
+    @fylterz = fylterz
+  end
+  attr_accessor :fylterz
+
+  filterable_object_name :fylterz
+  define_filter_map :query, :mapped_a, association: :field
+end
+
+filter_map = FilterMap.new(fytlerz: { query: 'H2O' })
+
+filter_map.mapped_a == 'H2O'
+filter_map.association_field = 'H2O'
+```
+
+#### Additional `Filterable` options
+You can specify several configuration options, for example a `filter_key_prefix` and a `filter_key_infix` to change the structure of the generated filter accessors.
 
 `filter_key_prefix :__` would result in key accessors like `__author_first_name`
 
 `filter_key_infix :__` would result in key accessors like `author__first_name`
 
-## ActiveRecord
+`filterable_object_name :fylterz` would use an internal filter state object named `@fyltrz` instead of the default `@filters`
+
+
+## `Rokaki::FilterModel` - Usage
+
+### ActiveRecord
 Include `Rokaki::FilterModel` in any ActiveRecord model (only AR >= 6.0.0 tested so far) you can generate the filter keys and the actual filter lookup code using the `filters` keyword on a model like so:-
 
 ```ruby
@@ -67,7 +148,7 @@ end
 
 
 class ArticleFilter
-  include FilterModel
+  include Rokaki::FilterModel
 
   filters :date, :title, author: [:first_name, :last_name]
 
@@ -96,7 +177,7 @@ You can use `like` (or, if you use postgres, the case insensitive `ilike`) to pe
 
 ```ruby
 class ArticleFilter
-  include FilterModel
+  include Rokaki::FilterModel
 
   filter :article,
     like: { # you can use ilike here instead if you use postgres and want case insensitive results
@@ -115,14 +196,45 @@ end
 ```
 Or
 
-#### 2. The porcelain command syntax
+#### 2. The `filter_map` command syntax
+`filter_map` takes the model name, then a single 'query' field and maps it to fields named in the options, this is useful if you want to search for a single value across many different fields or associated tables simultaneously. (builds on `define_filter_map`)
+
+
+```ruby
+class AuthorFilter
+  include Rokaki::FilterModel
+
+  filter_map :author, :query,
+    like: {
+      articles: {
+        title: :circumfix,
+        reviews: {
+          title: :circumfix
+        }
+      },
+    }
+
+  attr_accessor :filters, :model
+
+  def initialize(filters:)
+    @filters = filters
+  end
+end
+
+filters = { query: "Jiddu" }
+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.
+
+#### 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`
 
 
 ```ruby
 class ArticleFilter
-  include FilterModel
+  include Rokaki::FilterModel
 
   filters :date, :title, author: [:first_name, :last_name]
   like title: :circumfix
@@ -141,7 +253,7 @@ Or without the model in the initializer
 
 ```ruby
 class ArticleFilter
-  include FilterModel
+  include Rokaki::FilterModel
 
   filters :date, :title, author: [:first_name, :last_name]
   like title: :circumfix
@@ -161,6 +273,64 @@ Would produce a query with a LIKE which circumfixes '%' around the filter term,
 @model = @model.where('title LIKE :query', query: "%#{title}%")
 ```
 
+### Deep nesting
+You can filter joins both with basic matching and partial matching
+```ruby
+class ArticleFilter
+  include Rokaki::FilterModel
+
+  filter :author,
+    like: {
+      articles: {
+        reviews: {
+          title: :circumfix
+        }
+      },
+    }
+
+  attr_accessor :filters
+
+  def initialize(filters:)
+    @filters = filters
+  end
+end
+```
+
+### Array params
+You can pass array params (and partially match them), to filters (search multiple matches) in databases that support it (postgres) by passing the `db` param to the filter keyword, and passing an array of search terms at runtine
+
+```ruby
+class ArticleFilter
+  include Rokaki::FilterModel
+
+  filter :article,
+    like: {
+      author: {
+        first_name: :circumfix,
+        last_name: :circumfix
+      }
+    },
+    match: %i[title created_at],
+    db: :postgres
+
+  attr_accessor :filters
+
+  def initialize(filters:)
+    @filters = filters
+  end
+end
+
+filterable = ArticleFilter.new(filters:
+               {
+                 author: {
+                   first_name: ['Match One', 'Match Two']
+                 }
+               }
+             )
+
+filterable.results
+```
+
 
 ## Development
 

data/lib/rokaki/filter_model.rb

@@ -7,21 +7,52 @@ module Rokaki
       base.extend(ClassMethods)
     end
 
+    def prepare_terms(param, mode)
+      if param.is_a? Array
+        return param.map { |term| "%#{term}%" } if mode == :circumfix
+        return param.map { |term| "%#{term}" } if mode == :prefix
+        return param.map { |term| "#{term}%" } if mode == :suffix
+      else
+        return ["%#{param}%"] if mode == :circumfix
+        return ["%#{param}"] if mode == :prefix
+        return ["#{param}%"] if mode == :suffix
+      end
+    end
+
+
     module ClassMethods
       include Filterable::ClassMethods
 
       private
 
+      def filter_map(model, query_key, options)
+        filter_model(model)
+        @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]
+      end
+
       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)
-        define_filter_keys(*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|
@@ -42,7 +73,8 @@ module Rokaki
           prefix: filter_key_prefix,
           infix: filter_key_infix,
           like_semantics: @_like_semantics,
-          i_like_semantics: @i_like_semantics
+          i_like_semantics: @i_like_semantics,
+          db: @_filter_db
         )
         basic_filter.call
 
@@ -51,21 +83,14 @@ module Rokaki
         @_chain_filters << basic_filter.filter_template
       end
 
-      def like_semantics(type:, query:, filter:, mode:, key:)
-        query = "@model.where(\"#{key} #{type} :query\", "
-        query += "query: \"%\#{#{filter}}%\")" if mode == :circumfix
-        query += "query: \"%\#{#{filter}}\")" if mode == :prefix
-        query += "query: \"\#{#{filter}}%\")" if mode == :suffix
-        query
-      end
-
       def _chain_nested_filter(filters_object)
         nested_filter = NestedFilter.new(
           filter_key_object: filters_object,
           prefix: filter_key_prefix,
           infix: filter_key_infix,
           like_semantics: @_like_semantics,
-          i_like_semantics: @i_like_semantics
+          i_like_semantics: @i_like_semantics,
+          db: @_filter_db
         )
         nested_filter.call
 
@@ -78,13 +103,13 @@ module Rokaki
         end
       end
 
-      def associated_table(association)
-        @model.reflect_on_association(association).klass.table_name
-      end
+      # def associated_table(association)
+      #   @model.reflect_on_association(association).klass.table_name
+      # end
 
-      def filter_model(model)
-        @model = (model.is_a?(Class) ? model : Object.const_get(model.capitalize))
-        class_eval "def model; @model ||= #{@model}; 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;"
       end
 
       def like(args)
@@ -132,7 +157,7 @@ module Rokaki
       # filter_model method
       #
       def define_results
-        results_def = 'def results; model;'
+        results_def = 'def results; @model || set_model;'
         @_chain_filters.each do |item|
           results_def += item
         end

data/lib/rokaki/filter_model/basic_filter.rb

@@ -3,14 +3,15 @@
 module Rokaki
   module FilterModel
     class BasicFilter
-      def initialize(keys:, prefix:, infix:, like_semantics:, i_like_semantics:)
+      def initialize(keys:, prefix:, infix:, like_semantics:, i_like_semantics:, db:)
         @keys = keys
         @prefix = prefix
         @infix = infix
         @like_semantics = like_semantics
         @i_like_semantics = i_like_semantics
+        @db = db
       end
-      attr_reader :keys, :prefix, :infix, :like_semantics, :i_like_semantics
+      attr_reader :keys, :prefix, :infix, :like_semantics, :i_like_semantics, :db
       attr_accessor :filter_method, :filter_template
 
       def call
@@ -59,10 +60,16 @@ module Rokaki
       end
 
       def build_like_query(type:, query:, filter:, mode:, key:)
-        query = "@model.where(\"#{key} #{type} :query\", "
-        query += "query: \"%\#{#{filter}}%\")" if mode == :circumfix
-        query += "query: \"%\#{#{filter}}\")" if mode == :prefix
-        query += "query: \"\#{#{filter}}%\")" if mode == :suffix
+        if db == :postgres
+          query = "@model.where(\"#{key} #{type} ANY (ARRAY[?])\", "
+          query += "prepare_terms(#{filter}, :#{mode}))"
+        else
+          query = "@model.where(\"#{key} #{type} :query\", "
+          query += "query: \"%\#{#{filter}}%\")" if mode == :circumfix
+          query += "query: \"%\#{#{filter}}\")" if mode == :prefix
+          query += "query: \"\#{#{filter}}%\")" if mode == :suffix
+        end
+
         query
       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:)
+      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
@@ -12,8 +12,10 @@ module Rokaki
         @i_like_semantics = i_like_semantics
         @filter_methods = []
         @filter_templates = []
+        @db = db
+        @mode = mode
       end
-      attr_reader :filter_key_object, :prefix, :infix, :like_semantics, :i_like_semantics
+      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
@@ -55,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]
@@ -135,10 +137,16 @@ module Rokaki
       end
 
       def build_like_query(type:, query:, filter:, mode:, key:, leaf:)
-        query = "where(\"#{key}.#{leaf} #{type} :query\", "
-        query += "query: \"%\#{#{filter}}%\")" if mode == :circumfix
-        query += "query: \"%\#{#{filter}}\")" if mode == :prefix
-        query += "query: \"\#{#{filter}}%\")" if mode == :suffix
+        if db == :postgres
+          query = "where(\"#{key}.#{leaf} #{type} ANY (ARRAY[?])\", "
+          query += "prepare_terms(#{filter}, :#{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
+        end
+
         query
       end
 

data/lib/rokaki/filterable.rb

@@ -16,6 +16,17 @@ module Rokaki
         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
+        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
@@ -24,6 +35,10 @@ module Rokaki
         @filter_key_infix ||= infix
       end
 
+      def filterable_object_name(name = 'filters')
+        @filterable_object_name ||= name
+      end
+
       def _build_filter(keys)
         name    = @filter_key_prefix.to_s
         count   = keys.size - 1
@@ -33,12 +48,30 @@ module Rokaki
           name += filter_key_infix.to_s unless count == i
         end
 
-        class_eval "def #{name}; filters.dig(*#{keys}); end;", __FILE__, __LINE__
+        class_eval "def #{name}; #{filterable_object_name}.dig(*#{keys}); end;", __FILE__, __LINE__
+      end
+
+      def _map_filters(query_field, keys)
+        name    = @filter_key_prefix.to_s
+        count   = keys.size - 1
+
+        keys.each_with_index do |key, i|
+          name += key.to_s
+          name += filter_key_infix.to_s unless count == i
+        end
+
+        class_eval "def #{name}; #{filterable_object_name}.dig(:#{query_field}); end;", __FILE__, __LINE__
       end
 
       def _nested_key(filters_object)
         filters_object.keys.each do |key|
-          deep_map([key], filters_object[key])
+          deep_map([key], filters_object[key]) { |keys| _build_filter(keys) }
+        end
+      end
+
+      def _nested_map(query_field, filters_object)
+        filters_object.keys.each do |key|
+          deep_map([key], filters_object[key]) { |keys| _map_filters(query_field, keys) }
         end
       end
 
@@ -46,20 +79,24 @@ module Rokaki
         if value.is_a? Hash
           value.keys.map do |key|
             _keys = keys.dup << key
-            deep_map(_keys, value[key])
+            deep_map(_keys, value[key], &Proc.new)
           end
         end
 
         if value.is_a? Array
           value.each do |av|
+            if av.is_a? Symbol
             _keys = keys.dup << av
-            _build_filter(_keys)
+            yield _keys
+            else
+              deep_map(keys, av, &Proc.new)
+            end
           end
         end
 
         if value.is_a? Symbol
           _keys = keys.dup << value
-          _build_filter(_keys)
+          yield _keys
         end
       end
 

data/lib/rokaki/version.rb

@@ -1,3 +1,3 @@
 module Rokaki
-  VERSION = "0.6.0"
+  VERSION = "0.8.1.1"
 end

data/rokaki.gemspec

@@ -34,11 +34,13 @@ 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', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'sqlite3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rokaki
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.1.1
 platform: ruby
 authors:
 - Steve Martin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-07 00:00:00.000000000 Z
+date: 2020-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -114,14 +142,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -198,7 +226,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A web request filtering library