rokaki 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1731cab4173cbacc31862d09d6825ee0a6158ec70845bf78dfe3c9ed5cfa1edd
-  data.tar.gz: c9ff65505f778861b286f94196791bb7a36c79933e8b8136604ea1d9f97579da
+  metadata.gz: 0fd44ddd6bbfce39a8417111397fda97131f893d9e502b9a43c1068a18fae5ba
+  data.tar.gz: b17ce9c86ae2a7ed95a358662c48fde64e29c6d647a4d3e38f7d13ac6275f201
 SHA512:
-  metadata.gz: ee38b03675197b3cc8f9dca7f64e0475ea3c5265163de87e9110b0976f08ab6030a7e4b3a1540050ec8870ec64942af2982e9a688309e1100cc851eb6534aa6d
-  data.tar.gz: 9eb901aa514cd3efa3731193340033b3fc48a55e2ba76b398ecc289756a912531abda70a3604f2cf5d71d2799b5161ce11283b442267ad73e3cc94ad197df851
+  metadata.gz: 8574514a686795b089997a792cbf188ac82ed8751a94d5a0469d6ed92cf7860dd31d13762887972c6546e7e24f5427dfdd52f1c907c95e82de8f4509bec3d616
+  data.tar.gz: a38042fff170ed676be0fd9585b2fc9f1ce7ed9691fead44c9744724d6dfe94c65ed8ab005feaaaf7555268f653ab1906aa2765012036698cc8b4a43bb49c0e8

data/README.md

@@ -30,6 +30,7 @@ A simple example might be:-
       @filters = filters
       @articles = Article
     end
+
     attr_accessor :filters
 
     define_filter_keys :date, author: [:first_name, :last_name]
@@ -84,7 +85,35 @@ filtered_results = filter.results
 ```
 
 ### Partial matching
-You can use `like` to perform a partial match on a specific key, there are 3 options:- `:prefix`, `:circumfix` and `:suffix`.
+You can use `like` 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:-
+
+#### 1. The `filter` command syntax
+
+
+```
+class ArticleFilter
+  include FilterModel
+
+  filter :article,
+    like: {
+      author: {
+        first_name: :circumfix,
+        last_name: :circumfix
+      }
+    },
+
+  attr_accessor :filters
+
+  def initialize(filters:)
+    @filters = filters
+  end
+end
+```
+Or
+
+#### 2. 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`
 
 
 ```
@@ -103,6 +132,24 @@ class ArticleFilter
 end
 ```
 
+Or without the model in the initializer
+
+```
+class ArticleFilter
+  include FilterModel
+
+  filters :date, :title, author: [:first_name, :last_name]
+  like title: :circumfix
+  filter_model :article
+
+  attr_accessor :filters
+
+  def initialize(filters:)
+    @filters = filters
+  end
+end
+```
+
 Would produce a query with a LIKE which circumfixes '%' around the filter term, like:-
 
 ```

data/lib/rokaki/filter_model/like.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rokaki
+  module FilterModel
+    module Like
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def like(args)
+          raise ArgumentError, 'argument mush be a hash' unless args.is_a? Hash
+          @_like_semantics = (@_like_semantics || {}).merge(args)
+        end
+
+        def _chain_filter_like_type(key)
+          filter = "#{filter_key_prefix}#{key}"
+
+          query = "@model.where(\"#{key} LIKE :query\", "
+          if mode == :circumfix
+            query += "query: \"%\#{#{filter}}%\")"
+          end
+          if mode == :infix
+            query += "query: \"%\#{#{filter}}\")"
+          end
+          if mode == :suffix
+            query += "query: \"\#{#{filter}}%\")"
+          end
+          "#{query};"
+        end
+      end
+    end
+  end
+end

data/lib/rokaki/filter_model.rb

@@ -12,46 +12,57 @@ module Rokaki
 
       private
 
+      def filter(model, options)
+        filter_model(model)
+
+        like(options[:like]) if options[:like]
+        filters(*options[:match]) if options[:match]
+      end
+
       def filters(*filter_keys)
         define_filter_keys *filter_keys
 
-        @_chain_filters = []
+        @_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
+          _chain_filter([filter_key]) unless filter_key.is_a? Hash
+          _chain_nested(filter_key) if filter_key.is_a? Hash
         end
 
         define_results
       end
 
-      def _chain_filter(key)
-        filter = "#{filter_key_prefix}#{key}"
-        class_eval "def #{filter_key_prefix}filter_#{key};" \
-                   "#{_chain_filter_type(key)} end;",
-                   __FILE__, __LINE__ - 2
+      def _chain_filter(keys)
+        first_key = keys.shift
+        filter = "#{filter_key_prefix}#{first_key}"
+        name = first_key
+
+        keys.each do |key|
+          filter += "#{filter_key_infix}#{key}"
+          name += "#{filter_key_infix}#{key}"
+        end
 
-        @_chain_filters << "@model = #{filter_key_prefix}filter_#{key} if #{filter};"
+        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};"
       end
 
       def _chain_filter_type(key)
         filter = "#{filter_key_prefix}#{key}"
 
-        query = ""
+        query = ''
         if @_like_semantics && mode = @_like_semantics[key]
           query = "@model.where(\"#{key} LIKE :query\", "
-          if mode == :circumfix
-            query += "query: \"%\#{#{filter}}%\")"
-          end
-          if mode == :prefix
-            query += "query: \"%\#{#{filter}}\")"
-          end
-          if mode == :suffix
-            query += "query: \"\#{#{filter}}%\")"
-          end
+          query += "query: \"%\#{#{filter}}%\")" if mode == :circumfix
+          query += "query: \"%\#{#{filter}}\")" if mode == :prefix
+          query += "query: \"\#{#{filter}}%\")" if mode == :suffix
         else
           query = "@model.where(#{filter}: #{key})"
         end
-        "#{query};"
+
+        query
       end
 
       def _build_deep_chain(keys)
@@ -72,13 +83,15 @@ module Rokaki
           where = "{ #{key.to_s.pluralize}: { #{leaf}: #{name} } }"
         end
 
-
         joins = joins += out
         where = where += out
 
-        class_eval "def #{filter_key_prefix.to_s}filter_#{name};"\
-                   "@model.joins(#{joins}).where(#{where}); end;",
-                   __FILE__, __LINE__ - 2
+        # 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
@@ -94,12 +107,45 @@ module Rokaki
       end
 
       def filter_model(model)
-        @model = model
+        @model = (model.is_a?(Class) ? model : Object.const_get(model.capitalize))
+        class_eval "def model; @model ||= #{@model}; end;"
       end
 
       def like(args)
         raise ArgumentError, 'argument mush be a hash' unless args.is_a? Hash
+
+        like_keys = {base: []}
+        args.keys.each do |key|
+          map_like_keys(like_keys, args, key)
+        end
+
         @_like_semantics = (@_like_semantics || {}).merge(args)
+
+        base_keys = like_keys.delete(:base)
+        key_results = base_keys << like_keys
+
+        filters(*key_results)
+      end
+
+      def map_like_keys(key_result, base_object, key)
+        sub_object = base_object[key]
+        if sub_object.is_a? Hash
+          sub_object.keys.each do |sub_key|
+            sub_object_value = sub_object[sub_key]
+            if sub_object_value.is_a? Symbol
+              if key_result[key].is_a? Array
+                key_result[key] << sub_key
+              else
+                key_result[key] = [sub_key]
+              end
+            elsif sub_object_value.is_a? Hash
+              map_like_keys(key_result, sub_object, sub_key)
+            end
+          end
+        elsif sub_object.is_a? Symbol
+          key_result[:base] << key
+        end
+        key_result
       end
 
       def deep_chain(keys, value)
@@ -123,8 +169,11 @@ module Rokaki
         end
       end
 
+      # the model method is called to instatiate @model from the
+      # filter_model method
+      #
       def define_results
-        results_def = 'def results;'
+        results_def = 'def results;model;'
         @_chain_filters.each do |item|
           results_def += item
         end

data/lib/rokaki/filterable.rb

@@ -26,14 +26,11 @@ module Rokaki
 
       def _build_filter(keys)
         name    = @filter_key_prefix.to_s
-        filters = "filters"
         count   = keys.size - 1
 
         keys.each_with_index do |key, i|
           name += key.to_s
           name += filter_key_infix.to_s unless count == i
-
-          filters += "[:#{key}]"
         end
 
         class_eval "def #{name}; filters.dig(*#{keys}); end;", __FILE__, __LINE__
@@ -53,6 +50,7 @@ module Rokaki
           end
         end
 
+
         if value.is_a? Array
           value.each do |av|
             _keys = keys.dup << av

data/lib/rokaki/version.rb

@@ -1,3 +1,3 @@
 module Rokaki
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rokaki
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Steve Martin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-04 00:00:00.000000000 Z
+date: 2019-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -143,6 +143,7 @@ files:
 - bin/setup
 - lib/rokaki.rb
 - lib/rokaki/filter_model.rb
+- lib/rokaki/filter_model/like.rb
 - lib/rokaki/filterable.rb
 - lib/rokaki/version.rb
 - rokaki.gemspec