simple_search_filter 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e981724f0e77d67af48ccacf9531e15897cea6ad
+  data.tar.gz: 3b32bb82fc415e34c90ca415da6f26837fcaaa83
+SHA512:
+  metadata.gz: 09f429b6aaaa1474f87aa45b841b15c3ad9e99c775e0e9e6cdf5ce4f0abf23e449514895555a730d9eca70743f5ae3b0e0c462a0e1199a013bb482c8d6e97903
+  data.tar.gz: bf966381ef1d35b167f1e09385e7e2521c4e4f9ef845e0cfa99e00b194c976f0eae5ed3c704798e9ff4727280c0f7a6c60c92f52617caac5b7d991a63e10f914

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Max Ivak
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE 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.

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SimpleFilter'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/views/simple_search_filter/_buttons_apply_clear.html.haml

@@ -0,0 +1,2 @@
+<button type="submit" class="btn btn-primary btn-sm">Apply</button>
+<button type="button" class="btn btn-default btn-sm" onclick="$('#formFilter input[id=cmd]').val('clear'); document.getElementById('formFilter').reset(); document.getElementById('formFilter').submit(); return false;">Clear</button>

data/app/views/simple_search_filter/_buttons_apply_clear_inline.html.haml

@@ -0,0 +1,3 @@
+= render 'simple_search_filter/buttons_apply_clear', f: f
+
+

data/app/views/simple_search_filter/_field.html.haml

@@ -0,0 +1,13 @@
+- field = filter.fields[name]
+- formtype = field.formtype.to_s
+- name ||= field.name.to_s
+- v = filter.v(name)
+
+
+- if formtype=='text'
+  %input(type="text" class="form-control" id="filter[#{name}]" name="filter[#{name}]" placeholder="#{f.placeholder}" value="#{v}" )
+
+- elsif formtype=='hidden'
+  %input(type="hidden" class="form-control" id="filter[#{name}]" name="filter[#{name}]" value="#{v}")
+
+

data/app/views/simple_search_filter/_field_simple_form.html.haml

@@ -0,0 +1,22 @@
+- field = filter.fields[name]
+- formtype = field.formtype.to_s
+- name ||= field.name.to_s
+- v = filter.v(name)
+
+- if formtype=='empty'
+
+- elsif formtype=='text'
+  = f.input name, label: field.label, required: false
+
+- elsif formtype=='hidden'
+  = f.input name, as: :hidden
+
+- elsif formtype=='select'
+  - opt_base = {as: :select, required: false}
+  = f.input name, opt_base.merge(field.options)
+
+- elsif formtype=='autocomplete'
+  - opt_base = {as: :autocomplete, required: false}
+  - url = send(field.options[:source_query])
+  - field.options[:source_query] = url
+  = f.input name, opt_base.merge(field.options)

data/app/views/simple_search_filter/_fields.html.haml

@@ -0,0 +1,4 @@
+- filter.fields.each do |name, field|
+  -#= render :partial=>'simple_search_filter/filter_field', :locals => {:f=>field, :name=>name}
+  = render :partial=>'simple_search_filter/field_simple_form', :locals => {name: name, f: f, filter: filter}
+

data/app/views/simple_search_filter/_form.html.haml

@@ -0,0 +1,6 @@
+- if style==:inline
+  = render 'simple_search_filter/form_inline', local_assigns
+- elsif style==:horizontal
+  = render 'simple_search_filter/form_horizontal', local_assigns
+- else
+  = render 'simple_search_filter/form_horizontal', local_assigns

data/app/views/simple_search_filter/_form_horizontal.html.haml

@@ -0,0 +1,10 @@
+- url = send(filter_object.search_url)
+
+= simple_form_for(:filter, {url: url, method: filter_object.form_method, html: {id: 'formFilter', class: 'form-horizontal', role: 'form'}, wrapper: :horizontal_filter_form, wrapper_mappings: {check_boxes: :horizontal_filter_radio_and_checkboxes, radio_buttons: :horizontal_filter_radio_and_checkboxes, boolean: :horizontal_filter_boolean} }) do |f|
+  = hidden_field_tag 'cmd', 'apply'
+  = render 'simple_search_filter/fields', filter: filter_object, f: f
+  = render 'simple_search_filter/buttons_apply_clear_inline', filter: filter_object, f: f
+
+
+
+

data/app/views/simple_search_filter/_form_inline.html.haml

@@ -0,0 +1,6 @@
+- url = send(filter_object.search_url)
+
+= simple_form_for(:filter, {url: url, html: {id: 'formFilter', class: 'form-inline', role: 'form'}, wrapper: :inline_filter_form, wrapper_mappings: {} }) do |f|
+  = hidden_field_tag 'cmd', 'apply'
+  = render 'simple_search_filter/fields', filter: filter_object, f: f
+  = render 'simple_search_filter/buttons_apply_clear_inline', filter: filter_object, f: f

data/lib/simple_search_filter/controller.rb

@@ -0,0 +1,77 @@
+require 'active_support/concern'
+
+module SimpleSearchFilter
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+
+    end
+
+    def init_search_data(name)
+      # input
+      pg = params[@filter.page_param_name].to_i || 1
+      cmd = params[:cmd] || ''
+
+      # page
+      @filter.page = pg
+
+      # input from GET
+      @filter.fields.each do |name, f|
+        if params.has_key? name
+          @filter.set name, params[name]
+        end
+      end
+
+      # post - save filter and redirect
+      #if request.post? && params[:filter]
+      if params[:filter]
+        if cmd=='clear'
+          @filter.clear_data
+        else
+          @filter.set_data_from_form params[:filter]
+        end
+
+        #(redirect_to url and return) if @filter.search_method_post_and_redirect?
+      end
+
+      if cmd=='order'
+        @filter.set_order params[:orderby], params[:orderdir]
+        (redirect_to action: name.to_sym and return) if @filter.search_method_post_and_redirect?
+      end
+
+    end
+
+    module ClassMethods
+      def search_filter(name, options = {}, &block)
+        # raise "You need a block to build!" unless block_given?
+
+        init_method = "init_search_filter_#{name.to_s}"
+
+        define_method(init_method) do
+          prefix = options[:prefix] || "filter_#{params[:controller]}_#{name}"
+
+          # create Filter object
+          @filter = SimpleSearchFilter::Filter.new(self.session, prefix, options)
+
+          # define filter
+          @filter.instance_eval(&block)
+
+          # set data from params
+          init_search_data(name)
+
+        end
+
+        # before_action callback
+        self.before_action :"#{init_method}", only: [name.to_sym, options[:search_action]]
+
+
+        #
+        define_method("#{options[:search_action]}") do
+          redirect_to action: name.to_sym
+        end
+      end
+
+    end
+  end
+end

data/lib/simple_search_filter/engine.rb

@@ -0,0 +1,4 @@
+module SimpleSearchFilter
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/simple_search_filter/filter.rb

@@ -0,0 +1,371 @@
+require 'simple_search_filter/filter_field'
+
+module SimpleSearchFilter
+  class Filter
+    #
+    SEARCH_METHOD_GET = :get
+    SEARCH_METHOD_POST_AND_REDIRECT = :post_and_redirect
+
+    DEFAULT_SEARCH_METHOD = SEARCH_METHOD_GET
+
+    #
+    attr_accessor :prefix # session prefix
+    attr_accessor :fields # array of FilterField
+    attr_accessor :data # values
+
+
+
+    def initialize(_session, _prefix, opt={})
+      @prefix = _prefix
+      @session = _session
+
+      @fields ||={}
+
+      @options = opt
+      @options||={}
+
+      # init data
+      data()
+    end
+
+
+    def field(name, type, formtype, opt={})
+      add_field FilterField.new(name,type, formtype, opt)
+
+      if formtype.to_s==FilterField::FORM_TYPE_AUTOCOMPLETE
+        opt_int = opt.clone
+        opt_int[:default_value] = 0
+        add_field FilterField.new(name.to_s+'_id',FilterField::TYPE_INT, FilterField::FORM_TYPE_EMPTY, opt_int)
+      end
+
+    end
+
+
+
+    ############
+    # fields
+    ############
+
+    def add_field(f)
+      #@fields[f[:name]] = f
+      @fields[f.name] = f
+
+    end
+
+    def add_fields_from_array(a)
+      a.each{|fa| add_field fa}
+    end
+
+
+    def field_def_value(name)
+      name = name.to_sym
+
+      return nil if @fields[name].nil?
+
+      @fields[name].default_value
+    end
+
+
+    ############
+    # options
+    ############
+
+    def options
+      @options || {}
+    end
+
+    def search_method
+      options[:search_method] ||= DEFAULT_SEARCH_METHOD
+
+      options[:search_method]
+    end
+
+    def search_method_get?
+      search_method == SEARCH_METHOD_GET
+    end
+
+    def search_method_post_and_redirect?
+      search_method == SEARCH_METHOD_POST_AND_REDIRECT
+    end
+
+
+    def url
+      options[:url] || options[:search_url]
+    end
+
+    def search_url
+      options[:search_url]
+    end
+
+
+    def form_method
+      search_method_get? ? :get : :post
+    end
+
+    def page_param_name
+      options[:page_param_name] || SimpleSearchFilter.page_default_param_name
+    end
+
+
+
+    ############
+    # sessions
+    ############
+
+    def session_get(name, def_value)
+      @session[prefix+name] || def_value
+    end
+
+    def session_save(name, v)
+      @session[prefix+name] = v
+    end
+
+
+    ############
+    # data
+    ############
+
+
+    def data
+      return @data unless @data.nil?
+
+      # from session
+      @data_sess = session_get 'data', nil
+      unless @data_sess.nil?
+        @data = @data_sess
+      else
+
+      end
+
+      #
+      @data ||= {}
+
+      session_save('data', @data)
+
+      #
+      @data
+    end
+
+    def v(name, v_def=nil)
+      name = name.to_s
+
+      if (data.has_key? name) && (!data[name].nil?) && (!data[name].blank?)
+        return data[name]
+      end
+
+      field_def_value(name) || v_def
+    end
+
+
+    def v_empty?(name)
+      if (data.has_key? name) && (!data[name].nil?)
+        return true
+      end
+
+      # if v == default value
+
+    end
+
+    def set(field_name,v)
+      data[field_name.to_s] = @fields[field_name].fix_value(v)
+    end
+
+
+
+    def clear_data
+      @data = {}
+      session_save 'data', @data
+    end
+
+    def set_data_from_form(params)
+      # search for fields like filter[XXX]
+      params.each do |k, v|
+        name = k.to_sym
+
+        #if f =~ /^filter\[([^\]]+)\]$/
+          #name = Regexp.last_match(1)
+
+          next unless @fields.has_key? name
+
+          if @fields[name].type==FilterField::TYPE_INT
+            set name, (v.to_i rescue 0)
+          else
+            set name, v
+          end
+
+        #end
+      end
+
+      # default values from fields
+      @fields.each do |k, f|
+        name = k.to_s
+        next if @data.has_key? name
+
+        set name, field_def_value(name)
+      end
+
+    end
+
+
+    ####
+    # page
+    ####
+
+    def page
+      return @page unless @page.nil?
+
+      # from session
+      @v_sess = session_get 'page', nil
+      @page = @v_sess unless @v_sess.nil?
+
+      #
+      @page ||= 1
+
+      session_save 'page', @page
+
+      #
+      @page
+    end
+
+    def page=(value)
+      @page = value.to_i
+
+      session_save 'page', @page
+    end
+
+
+    ####
+    # order
+    ####
+
+    def default_order(order_by, order_dir)
+      set_default_order order_by, order_dir
+    end
+
+    def order
+      return @order unless @order.nil?
+
+      # from session
+      @v_sess = session_get 'order', nil
+      @order = @v_sess unless @v_sess.nil?
+
+      #
+      @order ||= []
+
+      session_save 'order', @order
+
+      #
+      @order
+    end
+
+    def order= (value)
+      @order = value
+
+      session_save 'order', @order
+    end
+
+    def set_default_order(order_by, order_dir)
+      return false if !order.nil? && !order.empty?
+
+      set_order(order_by, order_dir)
+
+    end
+
+
+    def set_order(order_by, order_dir)
+      self.order = [[order_by, order_dir]]
+    end
+
+    def get_order
+      order[0] if order.count>0
+      order[0]
+    end
+
+
+    def get_opposite_order_dir_for_column(name)
+      name = name.to_s
+
+      ord = order
+      return 'asc' if ord.empty?
+
+      if ord[0][0].to_s == name
+        return opposite_order_dir(ord[0][1])
+      end
+
+      return 'asc'
+    end
+
+    def opposite_order_dir(order_dir)
+      order_dir = order_dir.to_s
+      return 'asc' if order_dir=='desc'
+      return 'desc' if order_dir=='asc'
+      'asc'
+    end
+
+
+
+    def url_params_for_sortable_column(name)
+      p = {}
+      p[:cmd] = 'order'
+      p[:orderby] = name.to_s
+      p[:orderdir] = get_opposite_order_dir_for_column(name)
+
+      p
+    end
+
+
+
+    ########
+    # where
+    ########
+
+    def order_string
+      o = order
+      if o.empty?
+        orderby = 'id'
+        orderdir = 'asc'
+      else
+        orderby, orderdir = order[0]
+      end
+
+      "#{orderby} #{orderdir}"
+    end
+
+
+
+    def where_conditions
+      w_string = '1=1 '
+      w_values = []
+
+      @fields.each do |name, f|
+        val = v(name)
+
+        next if val.nil?
+
+        w_field = f.make_where(val)
+        next if w_field.nil?
+
+        w_cond, w_value = w_field
+
+        w_string << " AND #{w_cond} "
+        w_values << w_value
+      end
+
+      [w_string, *w_values]
+    end
+
+
+    ####
+
+    def method_missing(method_sym, *arguments, &block)
+      # the first argument is a Symbol, so you need to_s it if you want to pattern match
+      if @fields.has_key? method_sym
+        v(method_sym)
+      else
+        super
+      end
+    end
+
+  end
+
+end