rokaki 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebc3f6bb8aab2597c36dd7876792e22395a56a8d099b18cb0d48157e178e81bf
-  data.tar.gz: df20e88198f10346531fa5e5ffde6c8627ef5d19192119b07362865175e7357a
+  metadata.gz: b0654c6e63cc988e84b4df0a33b2055661bc5f7e29367923bdc1267fc4bbe64e
+  data.tar.gz: fd7f3e44cc48096389697d82f89b720a67900bbe073ce60e62828362fd46376d
 SHA512:
-  metadata.gz: 9f419fea3a5e3e292d8f44c6006df9ee799d49b4a1aa14820441c2e76c21cb514b668079ea9b727bc64cfb65d107efb162d49a1176bfadc5037b588db2323352
-  data.tar.gz: c683abe335a7d84718da478711c10704830470771e92420cd3ad3540a1062dbb065865e58fdcea4e0d5478cf4ab43293413ed7e0c6337e6f8d8a19e760a67555
+  metadata.gz: dc938b3a7c3632ed7f92a0452b87a91c5e50f0ae37b3f00cb5f9d79a65e0ca0f23f60d5b92b6cd709c287ddcf4a891bde460fd757df1e2fd8c4b0f551499fd05
+  data.tar.gz: a350805490d53b145b68813fdf9144b37871fa9b06942df0d2befb906e7912244258ffe14d0b5174bd0ab1fe7f92b4b9fcf650b847c1a36aefba2ecb8aee344b

data/.gitignore

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

data/Gemfile.lock

@@ -1,28 +1,32 @@
 PATH
   remote: .
   specs:
-    rokaki (0.4.1)
+    rokaki (0.8.0)
+      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)
-    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)
@@ -36,47 +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)
+    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.13.0)
     rake (10.5.0)
-    rb-fsevent (0.10.3)
-    rb-inotify (0.10.0)
+    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
@@ -84,13 +90,16 @@ PLATFORMS
 DEPENDENCIES
   activerecord
   bundler (~> 2.0)
+  factory_bot
   guard
   guard-rspec
+  pg
   pry
+  pry-byebug
   rake (~> 10.0)
   rokaki!
   rspec (~> 3.0)
   sqlite3
 
 BUNDLED WITH
-   2.0.2
+   2.1.4

data/Guardfile

@@ -36,6 +36,7 @@ guard :rspec, cmd: "bundle exec rspec" do
   watch(rspec.spec_support) { rspec.spec_dir }
   watch(rspec.spec_files)
 
+  watch(%r{^lib/rokaki/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
   # Ruby files
   ruby = dsl.ruby
   dsl.watch_spec_files_for(ruby.lib_files)

data/LICENSE.txt

@@ -19,3 +19,5 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
+
+f007539360

data/README.md

@@ -1,10 +1,9 @@
 # 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:
@@ -17,42 +16,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'
 ```
 
-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' } }`.
+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.
 
-## Additional options
-You can specify a `filter_key_prefix` and a `filter_key_infix` to change the structure of the accessors.
+#### 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 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.
+
+#### 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 +142,7 @@ end
 
 
 class ArticleFilter
-  include FilterModel
+  include Rokaki::FilterModel
 
   filters :date, :title, author: [:first_name, :last_name]
 
@@ -84,16 +159,19 @@ filter = ArticleFilter.new(filters: params[:filters])
 filtered_results = filter.results
 
 ```
+### Arrays of params
+You can also filter collections of fields, simply pass an array of filter values instead of a single value, eg:- `{ date: '10-10-10', author: { first_name: ['Author1', 'Author2'] } }`.
+
 
 ### Partial matching
-You can use `like` (or, if you use postgres, the case insensitive `ilike`) to perform a partial match on a specific key, there are 3 options:- `:prefix`, `:circumfix` and `:suffix`. There are two syntaxes you can use for this:-
+You can use `like` (or, if you use postgres, the case insensitive `ilike`) to perform a partial match on a specific field, there are 3 options:- `:prefix`, `:circumfix` and `:suffix`. There are two syntaxes you can use for this:-
 
 #### 1. The `filter` command syntax
 
 
 ```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
@@ -112,14 +190,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
@@ -138,7 +247,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
@@ -158,6 +267,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.rb

@@ -4,6 +4,8 @@ require 'rokaki/version'
 require 'rokaki/filterable'
 require 'rokaki/filter_model'
 require 'rokaki/filter_model/like_keys'
+require 'rokaki/filter_model/basic_filter'
+require 'rokaki/filter_model/nested_filter'
 
 module Rokaki
   class Error < StandardError; end

data/lib/rokaki/filter_model.rb

@@ -7,106 +7,96 @@ 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)
+        @_query_key = query_key
+
+        @_filter_db = options[:db] || :postgres
+        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_db = options[:db] || :postgres
         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 @_query_key
+          define_filter_map(@_query_key, *filter_keys)
+        else
+          define_filter_keys(*filter_keys)
+        end
 
         @_chain_filters ||= []
         filter_keys.each do |filter_key|
-          _chain_filter([filter_key]) unless filter_key.is_a? Hash
-          _chain_nested(filter_key) if filter_key.is_a? Hash
-        end
 
-        define_results
-      end
+          # TODO: does the key need casting to an array here?
+          _chain_filter(filter_key) unless filter_key.is_a? Hash
 
-      def _chain_filter(keys)
-        first_key = keys.shift
-        filter = "#{filter_key_prefix}#{first_key}"
-        name = first_key
+          _chain_nested_filter(filter_key) if filter_key.is_a? Hash
 
-        keys.each do |key|
-          filter += "#{filter_key_infix}#{key}"
-          name += "#{filter_key_infix}#{key}"
         end
 
-        filter_method = "def #{filter_key_prefix}filter_#{name};" \
-          "#{_chain_filter_type(name)} end;"
-
-        class_eval filter_method, __FILE__, __LINE__ - 2
-
-        @_chain_filters << "@model = #{filter_key_prefix}filter_#{name} if #{filter};"
+        define_results # writes out all the generated filters
       end
 
-      def _chain_filter_type(key)
-        filter = "#{filter_key_prefix}#{key}"
-
-        query = ''
-        if @_like_semantics && mode = @_like_semantics[key]
-          query = like_semantics(type: 'LIKE', query: query, filter: filter, mode: mode, key: key)
-        elsif @i_like_semantics && mode = @i_like_semantics[key]
-          query = like_semantics(type: 'ILIKE', query: query, filter: filter, mode: mode, key: key)
-        else
-          query = "@model.where(#{filter}: #{key})"
-        end
+      def _chain_filter(key)
+        basic_filter = BasicFilter.new(
+          keys: [key],
+          prefix: filter_key_prefix,
+          infix: filter_key_infix,
+          like_semantics: @_like_semantics,
+          i_like_semantics: @i_like_semantics,
+          db: @_filter_db
+        )
+        basic_filter.call
 
-        query
-      end
+        class_eval basic_filter.filter_method, __FILE__, __LINE__ - 2
 
-      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
+        @_chain_filters << basic_filter.filter_template
       end
 
-      def _build_deep_chain(keys)
-        name    = filter_key_prefix.to_s
-        count   = keys.size - 1
-
-        joins = ''
-        where = ''
-        out   = ''
-
-        leaf = keys.pop
-
-        keys.each_with_index do |key, _i|
-          next unless keys.length == 1
-          name  = "#{filter_key_prefix}#{key}#{filter_key_infix}#{leaf}"
-          joins = ":#{key}"
-
-          where = "{ #{key.to_s.pluralize}: { #{leaf}: #{name} } }"
+      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,
+          db: @_filter_db
+        )
+        nested_filter.call
+
+        nested_filter.filter_methods.each do |filter_method|
+          class_eval filter_method, __FILE__, __LINE__ - 2
         end
 
-        joins = joins += out
-        where = where += out
-
-        # chain filter here?
-        #
-        filter_method = "def #{filter_key_prefix}filter_#{name};"\
-                   "@model.joins(#{joins}).where(#{where}); end;"
-
-        class_eval filter_method, __FILE__, __LINE__ - 2
-
-        @_chain_filters << "@model = #{filter_key_prefix}filter_#{name} if #{name};"
-      end
-
-      def _chain_nested(filters_object)
-        filters_object.keys.each do |key|
-          deep_chain([key], filters_object[key])
+        nested_filter.filter_templates.each do |filter_template|
+          @_chain_filters << filter_template
         end
       end
 
@@ -114,9 +104,9 @@ module Rokaki
         @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)
@@ -124,8 +114,9 @@ module Rokaki
         @_like_semantics = (@_like_semantics || {}).merge(args)
 
         key_builder = LikeKeys.new(args)
+        keys = key_builder.call
 
-        filters(*key_builder.call)
+        filters(*keys)
       end
 
       def ilike(args)
@@ -133,8 +124,9 @@ module Rokaki
         @i_like_semantics = (@i_like_semantics || {}).merge(args)
 
         key_builder = LikeKeys.new(args)
+        keys = key_builder.call
 
-        filters(*key_builder.call)
+        filters(*keys)
       end
 
       def deep_chain(keys, value)
@@ -162,7 +154,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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Rokaki
+  module FilterModel
+    class BasicFilter
+      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, :db
+      attr_accessor :filter_method, :filter_template
+
+      def call
+        first_key = keys.shift
+        filter = "#{prefix}#{first_key}"
+        name = first_key
+
+        keys.each do |key|
+          filter += "#{infix}#{key}"
+          name += "#{infix}#{key}"
+        end
+
+        @filter_method = "def #{prefix}filter_#{name};" \
+          "#{_chain_filter_type(name)} end;"
+
+        # class_eval filter_method, __FILE__, __LINE__ - 2
+
+        @filter_template = "@model = #{prefix}filter_#{name} if #{filter};"
+      end
+
+      def _chain_filter_type(key)
+        filter = "#{prefix}#{key}"
+        query  = ''
+
+        if like_semantics && mode = like_semantics[key]
+          query = build_like_query(
+            type: 'LIKE',
+            query: query,
+            filter: filter,
+            mode: mode,
+            key: key
+          )
+        elsif i_like_semantics && mode = i_like_semantics[key]
+          query = build_like_query(
+            type: 'ILIKE',
+            query: query,
+            filter: filter,
+            mode: mode,
+            key: key
+          )
+        else
+          query = "@model.where(#{key}: #{filter})"
+        end
+
+        query
+      end
+
+      def build_like_query(type:, query:, filter:, mode:, key:)
+        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
+  end
+end
+

data/lib/rokaki/filter_model/filter_chain.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rokaki
+  module FilterModel
+    class FilterChain
+      def initialize(keys)
+        @keys = keys
+        @filter_chain = []
+      end
+    end
+  end
+end
+

data/lib/rokaki/filter_model/like_keys.rb

@@ -2,6 +2,10 @@
 
 module Rokaki
   module FilterModel
+    # Converts deep hashes into keys
+    # effectively drops the leaf values and make's their
+    # keys the leaves
+    #
     class LikeKeys
       def initialize(args)
         @args = args

data/lib/rokaki/filter_model/nested_filter.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+require 'active_support/inflector'
+
+module Rokaki
+  module FilterModel
+    class NestedFilter
+      def initialize(filter_key_object:, prefix:, infix:, like_semantics:, i_like_semantics:, db:)
+        @filter_key_object = filter_key_object
+        @prefix = prefix
+        @infix = infix
+        @like_semantics = like_semantics
+        @i_like_semantics = i_like_semantics
+        @filter_methods = []
+        @filter_templates = []
+        @db = db
+      end
+      attr_reader :filter_key_object, :prefix, :infix, :like_semantics, :i_like_semantics, :db
+      attr_accessor :filter_methods, :filter_templates
+
+      def call # _chain_nested_filter
+        filter_key_object.keys.each do |key|
+          deep_chain([key], filter_key_object[key])
+        end
+      end
+
+      private
+
+      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
+      end
+
+      def find_like_key(keys)
+        return nil unless like_semantics && like_semantics.keys.any?
+        current_like_key = like_semantics
+        keys.each do |key|
+          current_like_key = current_like_key[key]
+        end
+        current_like_key
+      end
+
+      def find_i_like_key(keys)
+        return nil unless like_semantics && i_like_semantics.keys.any?
+        current_like_key = i_like_semantics
+        keys.each do |key|
+          current_like_key = current_like_key[key]
+        end
+        current_like_key
+      end
+
+      def _build_deep_chain(keys)
+        name    = '' # prefix.to_s
+        count   = keys.size - 1
+
+        joins_before = []
+        joins_after = []
+        joins = ''
+        where_before = []
+        where_after = []
+        out   = ''
+        mode = nil
+        type = nil
+        leaf = nil
+
+        if mode = find_like_key(keys)
+          type = 'LIKE'
+        elsif mode = find_i_like_key(keys)
+          type = 'ILIKE'
+        end
+        leaf = keys.pop
+
+        keys.each_with_index do |key, i|
+          if keys.length == 1
+            joins_before << ":#{key}"
+          else
+            if i == 0
+              joins_before << "#{key}: "
+            elsif (keys.length-1) == i
+              joins_before << " :#{key}"
+            else
+              joins_before << "{ #{key}:"
+              joins_after << " }"
+            end
+          end
+
+          name += "#{key}#{infix}"
+          where_before.push("{ #{key.to_s.pluralize}: ")
+          where_after.push(" }")
+        end
+
+        joins = joins_before + joins_after
+
+        name += "#{leaf}"
+        where_middle = ["{ #{leaf}: #{prefix}#{name} }"]
+
+        where = where_before + where_middle + where_after
+        joins = joins.join
+        where = where.join
+
+        if mode
+          query = build_like_query(
+            type: type,
+            query: '',
+            filter: "#{prefix}#{name}",
+            mode: mode,
+            key: keys.last.to_s.pluralize,
+            leaf: leaf
+          )
+
+          @filter_methods << "def #{prefix}filter#{infix}#{name};"\
+            "@model.joins(#{joins}).#{query}; end;"
+
+          @filter_templates << "@model = #{prefix}filter#{infix}#{name} if #{prefix}#{name};"
+        else
+          @filter_methods << "def #{prefix}filter#{infix}#{name};"\
+            "@model.joins(#{joins}).where(#{where}); end;"
+
+          @filter_templates << "@model = #{prefix}filter#{infix}#{name} if #{prefix}#{name};"
+        end
+      end
+
+      def build_like_query(type:, query:, filter:, mode:, key:, leaf:)
+        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
+
+    end
+  end
+end
+

data/lib/rokaki/filterable.rb

@@ -16,6 +16,13 @@ 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 filter_key_prefix(prefix = nil)
         @filter_key_prefix ||= prefix
       end
@@ -24,6 +31,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 +44,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,21 +75,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.5.0"
+  VERSION = "0.8.0"
 end

data/rokaki.gemspec

@@ -1,39 +1,46 @@
-lib = File.expand_path("lib", __dir__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "rokaki/version"
+require 'rokaki/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "rokaki"
+  spec.name          = 'rokaki'
   spec.version       = Rokaki::VERSION
-  spec.authors       = ["Steve Martin"]
-  spec.email         = ["steve@martian.media"]
+  spec.authors       = ['Steve Martin']
+  spec.email         = ['steve@martian.media']
 
-  spec.summary       = %q{A web request filtering library}
-  spec.description   = %q{A dsl for filtering data in web requests}
-  spec.homepage      = "https://github.com/tevio/rokaki"
-  spec.license       = "MIT"
+  spec.summary       = 'A web request filtering library'
+  spec.description   = 'A dsl for filtering data in web requests'
+  spec.homepage      = 'https://github.com/tevio/rokaki'
+  spec.license       = 'MIT'
 
   # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
 
-  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata['homepage_uri'] = spec.homepage
   # spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
   # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "guard"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "guard-rspec"
-  spec.add_development_dependency "activerecord"
-  spec.add_development_dependency "sqlite3"
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport'
+
+  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 'rspec', '~> 3.0'
+  spec.add_development_dependency 'sqlite3'
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rokaki
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Steve Martin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-17 00:00:00.000000000 Z
+date: 2020-06-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -25,35 +53,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: factory_bot
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: guard
   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: guard
+  name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: guard-rspec
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -108,6 +136,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  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: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -143,7 +199,10 @@ files:
 - bin/setup
 - lib/rokaki.rb
 - lib/rokaki/filter_model.rb
+- lib/rokaki/filter_model/basic_filter.rb
+- lib/rokaki/filter_model/filter_chain.rb
 - lib/rokaki/filter_model/like_keys.rb
+- lib/rokaki/filter_model/nested_filter.rb
 - lib/rokaki/filterable.rb
 - lib/rokaki/version.rb
 - rokaki.gemspec
@@ -167,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