# frozen_string_literal: true module Rokaki module FilterModel include Filterable def self.included(base) base.extend(ClassMethods) end module ClassMethods include Filterable::ClassMethods private def filters(*filter_keys) define_filter_keys *filter_keys @_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 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 @_chain_filters << "@model = #{filter_key_prefix}filter_#{key} if #{filter};" end def _chain_filter_type(key) filter = "#{filter_key_prefix}#{key}" 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 else query = "@model.where(#{filter}: #{key})" end "#{query};" 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} } }" 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_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]) end end def associated_table(association) @model.reflect_on_association(association).klass.table_name end def filter_model(model) @model = model end def like(args) raise ArgumentError, 'argument mush be a hash' unless args.is_a? Hash @_like_semantics = (@_like_semantics || {}).merge(args) 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 end def define_results results_def = 'def results;' @_chain_filters.each do |item| results_def += item end results_def += '@model;end;' class_eval results_def, __FILE__, __LINE__ end end end end