turbo_filter 0.0.1 → 1.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWVhNGFlM2E1YmIyYjEwN2EwNTZjYzE3NTA2OGU1M2U5Yzk3MDk2Mg==
+  data.tar.gz: !binary |-
+    ZmQwOTE5ZmY0ODdiY2QyZTYzMGQ4YTk1NmI2NmU3MzlhOTQ2MzQyNQ==
+SHA512:
+  metadata.gz: !binary |-
+    MGYyZmUwZjNkZTY5ODMxY2IzNmNiMGJhYjMyMzA4NDI3Nzg3ZDMyMjUzMzEy
+    OTdiZDgwYTBjOWExZDk4ZTUzYmVjYTMzNDhiZjAwZDM5OWY1NTA1N2FmOGQx
+    ZGJiYTVjNzFjYWUyOTYwZDgyNjBhYTlhYTE2NzhmZTI2YTkyNWQ=
+  data.tar.gz: !binary |-
+    ZGYzNmY0NTkzNzQ5NTYyMDg4YjJiNjNlZWQxY2Q2MzMyNzRjYjU2MTI3MDc5
+    MTE5N2M4YjFlMDA2YzJmYTIwNmUzNTg1ZGY4YTNiZWQ1NmYxOTMxZTFhMzg3
+    ZTYyMWQ3OWE4YzlhMWMwYjUzZDZiOWE5YTUxMGE2YmY2ZDBmNjM=

data/README.md

@@ -1,6 +1,6 @@
 # TurboFilter
 
-TODO: Write a gem description
+Filters your ActiveRecord table records.
 
 ## Installation
 
@@ -18,7 +18,38 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+  Add turbo_filter to application.js
+
+    //= require turbo_filter
+
+  In Controller:
+
+    class ArticlesController < ApplicationController
+    ...
+      def index
+        retrieve_turbo_filter_query(Article)
+        @articles = Article.where(@turbo_filter_query.statement).paginate(page: params[:page], per_page: 100)
+      end
+    ...
+    end
+
+  In Models: Add `to_s` method like below to `Article -> belongs_to` assocation classes.
+
+    class User < ActiveRecord::Base
+    ...
+      def to_s
+        name
+      end
+    ...
+    end
+
+  In Views: Add `turbo_filters` helper method to `app/views/articles/index.html.erb` view filters.
+
+    <%= turbo_filters %>
+
+  UI Compatibility: boostrap compatible.
+  Requires jQueryDatePicker, Turbo links enabled.
+
 
 ## Contributing
 

data/app/assets/javascripts/turbo_filter.js

@@ -0,0 +1,362 @@
+function checkAll(id, checked) {
+  $('#'+id).find('input[type=checkbox]:enabled').prop('checked', checked);
+}
+
+function toggleCheckboxesBySelector(selector) {
+  var all_checked = true;
+  $(selector).each(function(index) {
+    if (!$(this).is(':checked')) { all_checked = false; }
+  });
+  $(selector).prop('checked', !all_checked);
+}
+
+function showAndScrollTo(id, focus) {
+  $('#'+id).show();
+  if (focus !== null) {
+    $('#'+focus).focus();
+  }
+  $('html, body').animate({scrollTop: $('#'+id).offset().top}, 100);
+}
+
+function toggleRowGroup(el) {
+  var tr = $(el).parents('tr').first();
+  var n = tr.next();
+  tr.toggleClass('open');
+  while (n.length && !n.hasClass('group')) {
+    n.toggle();
+    n = n.next('tr');
+  }
+}
+
+function collapseAllRowGroups(el) {
+  var tbody = $(el).parents('tbody').first();
+  tbody.children('tr').each(function(index) {
+    if ($(this).hasClass('group')) {
+      $(this).removeClass('open');
+    } else {
+      $(this).hide();
+    }
+  });
+}
+
+function expandAllRowGroups(el) {
+  var tbody = $(el).parents('tbody').first();
+  tbody.children('tr').each(function(index) {
+    if ($(this).hasClass('group')) {
+      $(this).addClass('open');
+    } else {
+      $(this).show();
+    }
+  });
+}
+
+function toggleAllRowGroups(el) {
+  var tr = $(el).parents('tr').first();
+  if (tr.hasClass('open')) {
+    collapseAllRowGroups(el);
+  } else {
+    expandAllRowGroups(el);
+  }
+}
+
+function toggleFieldset(el) {
+  var fieldset = $(el).parents('fieldset').first();
+  fieldset.toggleClass('collapsed');
+  fieldset.children('div').toggle();
+}
+
+function hideFieldset(el) {
+  var fieldset = $(el).parents('fieldset').first();
+  fieldset.toggleClass('collapsed');
+  fieldset.children('div').hide();
+}
+
+function initFilters() {
+  $('#add_filter_select').change(function() {
+    addFilter($(this).val(), '', []);
+  });
+  $('#filters-table td.field input[type=checkbox]').each(function() {
+    toggleFilter($(this).val());
+  });
+  $('#filters-table').on('click', 'td.field input[type=checkbox]', function() {
+    toggleFilter($(this).val());
+  });
+  $('#filters-table').on('click', '.toggle-multiselect', function() {
+    toggleMultiSelect($(this).siblings('select'));
+  });
+  $('#filters-table').on('keypress', 'input[type=text]', function(e) {
+    if (e.keyCode == 13) submit_turbo_filter_query_form("turbo_filter_query_form");
+  });
+}
+
+function addFilter(field, operator, values) {
+  var fieldId = field.replace('.', '_');
+  var tr = $('#tr_'+fieldId);
+  if (tr.length > 0) {
+    tr.show();
+  } else {
+    buildFilterRow(field, operator, values);
+  }
+  $('#cb_'+fieldId).prop('checked', true);
+  toggleFilter(field);
+  $('#add_filter_select').val('').children('option').each(function() {
+    if ($(this).attr('value') == field) {
+      $(this).attr('disabled', true);
+    }
+  });
+}
+
+function buildFilterRow(field, operator, values) {
+  var fieldId = field.replace('.', '_');
+  var filterTable = $("#filters-table");
+  var filterOptions = availableFilters[field];
+  if (!filterOptions) return;
+  var operators = operatorByType[filterOptions['type']];
+  var filterValues = filterOptions['values'];
+  var datepickerOptions = {dateFormat: 'yy-mm-dd', showButtonPanel: true, changeMonth: true, changeYear: true};
+  var i, select;
+
+  var tr = $('<tr class="filter">').attr('id', 'tr_'+fieldId).html(
+    '<td class="field"><input checked="checked" id="cb_'+fieldId+'" name="f[]" value="'+field+'" type="checkbox"><label for="cb_'+fieldId+'"> '+filterOptions['name']+'</label></td>' +
+    '<td class="operator"><select id="operators_'+fieldId+'" name="op['+field+']"></td>' +
+    '<td class="values"></td>'
+  );
+  filterTable.append(tr);
+
+  select = tr.find('td.operator select');
+  for (i = 0; i < operators.length; i++) {
+    var option = $('<option>').val(operators[i]).text(operatorLabels[operators[i]]);
+    if (operators[i] == operator) { option.attr('selected', true); }
+    select.append(option);
+  }
+  select.change(function(){ toggleOperator(field); });
+
+  switch (filterOptions['type']) {
+  case "list":
+  case "list_optional":
+  case "list_status":
+  case "list_subprojects":
+    tr.find('td.values').append(
+      '<span style="display:none;"><select class="value" id="values_'+fieldId+'_1" name="v['+field+'][]"></select>' +
+      ' <span class="toggle-multiselect">&nbsp;</span></span>'
+    );
+    select = tr.find('td.values select');
+    if (values.length > 1) { select.attr('multiple', true); }
+    for (i = 0; i < filterValues.length; i++) {
+      var filterValue = filterValues[i];
+      var option = $('<option>');
+      if ($.isArray(filterValue)) {
+        option.val(filterValue[1]).text(filterValue[0]);
+        if ($.inArray(filterValue[1], values) > -1) {option.attr('selected', true);}
+      } else {
+        option.val(filterValue).text(filterValue);
+        if ($.inArray(filterValue, values) > -1) {option.attr('selected', true);}
+      }
+      select.append(option);
+    }
+    break;
+  case "date":
+  case "date_past":
+    tr.find('td.values').append(
+      '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="10" class="value date_value" /></span>' +
+      ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="10" class="value date_value" /></span>' +
+      ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="3" class="value" /> '+labelDayPlural+'</span>'
+    );
+    $('#values_'+fieldId+'_1').val(values[0]).datepicker(datepickerOptions);
+    $('#values_'+fieldId+'_2').val(values[1]).datepicker(datepickerOptions);
+    $('#values_'+fieldId).val(values[0]);
+    break;
+  case "string":
+  case "text":
+    tr.find('td.values').append(
+      '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="30" class="value" /></span>'
+    );
+    $('#values_'+fieldId).val(values[0]);
+    break;
+  case "relation":
+    tr.find('td.values').append(
+      '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="6" class="value" /></span>' +
+      '<span style="display:none;"><select class="value" name="v['+field+'][]" id="values_'+fieldId+'_1"></select></span>'
+    );
+    $('#values_'+fieldId).val(values[0]);
+    select = tr.find('td.values select');
+    for (i = 0; i < allProjects.length; i++) {
+      var filterValue = allProjects[i];
+      var option = $('<option>');
+      option.val(filterValue[1]).text(filterValue[0]);
+      if (values[0] == filterValue[1]) { option.attr('selected', true); }
+      select.append(option);
+    }
+    break;
+  case "integer":
+  case "float":
+    tr.find('td.values').append(
+      '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="6" class="value" /></span>' +
+      ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="6" class="value" /></span>'
+    );
+    $('#values_'+fieldId+'_1').val(values[0]);
+    $('#values_'+fieldId+'_2').val(values[1]);
+    break;
+  }
+}
+
+function toggleFilter(field) {
+  var fieldId = field.replace('.', '_');
+  if ($('#cb_' + fieldId).is(':checked')) {
+    $("#operators_" + fieldId).show().removeAttr('disabled');
+    toggleOperator(field);
+  } else {
+    $("#operators_" + fieldId).hide().attr('disabled', true);
+    enableValues(field, []);
+  }
+}
+
+function enableValues(field, indexes) {
+  var fieldId = field.replace('.', '_');
+  $('#tr_'+fieldId+' td.values .value').each(function(index) {
+    if ($.inArray(index, indexes) >= 0) {
+      $(this).removeAttr('disabled');
+      $(this).parents('span').first().show();
+    } else {
+      $(this).val('');
+      $(this).attr('disabled', true);
+      $(this).parents('span').first().hide();
+    }
+
+    if ($(this).hasClass('group')) {
+      $(this).addClass('open');
+    } else {
+      $(this).show();
+    }
+  });
+}
+
+function toggleOperator(field) {
+  var fieldId = field.replace('.', '_');
+  var operator = $("#operators_" + fieldId);
+  switch (operator.val()) {
+    case "!*":
+    case "*":
+    case "t":
+    case "ld":
+    case "w":
+    case "lw":
+    case "l2w":
+    case "m":
+    case "lm":
+    case "y":
+    case "o":
+    case "c":
+      enableValues(field, []);
+      break;
+    case "><":
+      enableValues(field, [0,1]);
+      break;
+    case "<t+":
+    case ">t+":
+    case "><t+":
+    case "t+":
+    case ">t-":
+    case "<t-":
+    case "><t-":
+    case "t-":
+      enableValues(field, [2]);
+      break;
+    case "=p":
+    case "=!p":
+    case "!p":
+      enableValues(field, [1]);
+      break;
+    default:
+      enableValues(field, [0]);
+      break;
+  }
+}
+
+function toggleMultiSelect(el) {
+  if (el.attr('multiple')) {
+    el.removeAttr('multiple');
+    el.attr('size', 1);
+  } else {
+    el.attr('multiple', true);
+    if (el.children().length > 10)
+      el.attr('size', 10);
+    else
+      el.attr('size', 4);
+  }
+}
+
+function validate_turbo_filters(id) {
+  var arr = 0;
+  $(".value:visible").each(function(){
+    if(!$(this).val().trim()){
+      $(this).css({"border-color": "RED"});
+      $(this).attr('placeholder', "can't be empty.");
+      arr += 1;
+    }
+  });
+  return arr;
+}
+
+function submit_turbo_filter_query_form(id) {
+  if(validate_turbo_filters(id) === 0)
+    $('#'+id).submit();
+}
+
+function showModal(id, width) {
+  var el = $('#'+id).first();
+  if (el.length === 0 || el.is(':visible')) {return;}
+  var title = el.find('h3.title').text();
+  el.dialog({
+    width: width,
+    modal: true,
+    resizable: false,
+    dialogClass: 'modal',
+    title: title
+  });
+  el.find("input[type=text], input[type=submit]").first().focus();
+}
+
+function hideModal(el) {
+  var modal;
+  if (el) {
+    modal = $(el).parents('.ui-dialog-content');
+  } else {
+    modal = $('#ajax-modal');
+  }
+  modal.dialog("close");
+}
+
+function setupAjaxIndicator() {
+  $(document).bind('ajaxSend', function(event, xhr, settings) {
+    if ($('.ajax-loading').length === 0 && settings.contentType != 'application/octet-stream') {
+      $('#ajax-indicator').show();
+    }
+  });
+  $(document).bind('ajaxStop', function() {
+    $('#ajax-indicator').hide();
+  });
+}
+
+function hideOnLoad() {
+  $('.hol').hide();
+}
+
+function addFormObserversForDoubleSubmit() {
+  $('form[method=post]').each(function() {
+    if (!$(this).hasClass('multiple-submit')) {
+      $(this).submit(function(form_submission) {
+        if ($(form_submission.target).attr('data-submitted')) {
+          form_submission.preventDefault();
+        } else {
+          $(form_submission.target).attr('data-submitted', true);
+        }
+      });
+    }
+  });
+}
+
+// $(document).ready(setupAjaxIndicator);
+// $(document).ready(hideOnLoad);
+// $(document).ready(addFormObserversForDoubleSubmit);
+

data/app/views/turbo_filters/_filters.html.erb

@@ -0,0 +1,31 @@
+<script type="text/javascript">
+var operatorLabels = <%= raw_json TurboFilter::TurboFilterQuery.operators_labels %>;
+var operatorByType = <%= raw_json TurboFilter::TurboFilterQuery.operators_by_filter_type %>;
+var availableFilters = <%= raw_json turbo_filter_query.available_filters_as_json %>;
+var labelDayPlural = <%= raw_json t(:label_day_plural) %>;
+$(document).on('ready page:load', function () {
+  initFilters();
+  <% turbo_filter_query.filters.each do |field, options| %>
+  addFilter("<%= field %>", <%= raw_json turbo_filter_query.operator_for(field) %>, <%= raw_json turbo_filter_query.values_for(field) %>);
+  <% end %>
+});
+</script>
+<h2>Turbo Filters</h2>
+<%= form_tag({ :controller => turbo_filter_query.instance_values["filters_for_class"].to_s.pluralize.downcase, :action => 'index' },
+            :method => :get, :id => 'turbo_filter_query_form') do %>
+<table style="width:100%">
+  <tr>
+    <td>
+      <table id="filters-table"></table>
+    </td>
+    <td class="add-filter">
+      <%= label_tag('add_filter_select', t(:label_filter_add)) %>
+      <%= select_tag 'add_filter_select', filters_options_for_select(turbo_filter_query), :name => nil %>
+    </td>
+  </tr>
+</table>
+<%= hidden_field_tag 'f[]', '' %>
+<%= link_to_function t(:apply), 'submit_turbo_filter_query_form("turbo_filter_query_form")', :class => 'btn btn-primary' %>
+<%= link_to t(:clear), { :set_filter => 1 }, "data-no-turbolink" => true, :class => 'btn'  %>
+<% end -%>
+<hr>

data/config/locales/en.yml

@@ -0,0 +1,32 @@
+en:
+  label_day_plural: Days
+  label_filter_add: Add Filter
+  label_filter_plural: Filters
+  label_equals: is
+  label_not_equals: is not
+  label_in_less_than: in less than
+  label_in_more_than: in more than
+  label_in_the_next_days: in the next
+  label_in_the_past_days: in the past
+  label_greater_or_equal: '>='
+  label_less_or_equal: '<='
+  label_between: between
+  label_in: in
+  label_today: today
+  label_all_time: all time
+  label_yesterday: yesterday
+  label_this_week: this week
+  label_last_week: last week
+  label_last_n_weeks: "last %{count} weeks"
+  label_last_n_days: "last %{count} days"
+  label_this_month: this month
+  label_last_month: last month
+  label_this_year: this year
+  label_date_range: Date range
+  label_less_than_ago: less than days ago
+  label_more_than_ago: more than days ago
+  label_ago: days ago
+  label_contains: contains
+  label_not_contains: doesn't contain
+  label_any: any
+  label_none: none

data/lib/turbo_filter/engine.rb

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

data/lib/turbo_filter/turbo_filter_controller.rb

@@ -0,0 +1,36 @@
+module TurboFilter
+  module TurboFilterController
+
+    # Retrieve query from session or build a new query
+    def retrieve_turbo_filter_query(filters_for_class)
+      if params[:set_filter] || session[:query].nil?
+        # Give it a name, required to be valid
+        @turbo_filter_query = TurboFilter::TurboFilterQuery.new(filters_for_class)
+        build_turbo_filter_query_from_params
+        session[:query] = {:filters => @turbo_filter_query.filters}
+      else
+        # retrieve from session
+        @turbo_filter_query ||= TurboFilter::TurboFilterQuery.new(filters_for_class, session[:query][:filters])
+        build_turbo_filter_query_from_params
+      end
+    end
+
+    def retrieve_turbo_filter_query_from_session
+      if session[:query]
+        @turbo_filter_query = TurboFilter::TurboFilterQuery.new(filters_for_class, session[:query][:filters])
+      end
+    end
+
+    def build_turbo_filter_query_from_params
+      if params[:f]
+        filters = if session[:query]
+                    session[:query][:filters] = session[:query][:filters].select { |k,v| params[:f].reject(&:blank?).include?(k) }
+                  else
+                    {}
+                  end
+        @turbo_filter_query.filters = filters
+        @turbo_filter_query.add_filters(params[:f], params[:operators] || params[:op], params[:values] || params[:v])
+      end
+    end
+  end
+end

data/lib/turbo_filter/turbo_filter_helper.rb

@@ -0,0 +1,28 @@
+module TurboFilter
+  module TurboFilterHelper
+
+    def turbo_filters
+      render :partial => 'turbo_filters/filters', :layout => false, :locals => {:turbo_filter_query => @turbo_filter_query}
+    end
+
+    def filters_options_for_select(query)
+      options_for_select(filters_options(query))
+    end
+
+    def filters_options(query)
+      options = [[]]
+      options += query.available_filters.map do |field, field_options|
+        [field_options[:name], field]
+      end
+    end
+
+    # Helper to render JSON in views
+    def raw_json(arg)
+      arg.to_json.to_s.gsub('/', '\/').html_safe
+    end
+
+    def link_to_function(name, function, html_options={})
+      content_tag(:a, name, {:href => '#', :onclick => "#{function}; return false;"}.merge(html_options))
+    end
+  end
+end

data/lib/turbo_filter/turbo_filter_query.rb

@@ -0,0 +1,353 @@
+module TurboFilter
+  class TurboFilterQuery
+
+      class_attribute :filters
+      class_attribute :operators
+      self.operators = {
+        "="   => :label_equals,
+        "!"   => :label_not_equals,
+        "!*"  => :label_none,
+        "*"   => :label_any,
+        ">="  => :label_greater_or_equal,
+        "<="  => :label_less_or_equal,
+        "><"  => :label_between,
+        "<t+" => :label_in_less_than,
+        ">t+" => :label_in_more_than,
+        "><t+"=> :label_in_the_next_days,
+        "t+"  => :label_in,
+        "t"   => :label_today,
+        "ld"  => :label_yesterday,
+        "w"   => :label_this_week,
+        "lw"  => :label_last_week,
+        "l2w" => [:label_last_n_weeks, {:count => 2}],
+        "m"   => :label_this_month,
+        "lm"  => :label_last_month,
+        "y"   => :label_this_year,
+        ">t-" => :label_less_than_ago,
+        "<t-" => :label_more_than_ago,
+        "><t-"=> :label_in_the_past_days,
+        "t-"  => :label_ago,
+        "~"   => :label_contains,
+        "!~"  => :label_not_contains
+      }
+
+      class_attribute :operators_by_filter_type
+      self.operators_by_filter_type = {
+        :list => [ "=", "!" ],
+        :list_optional => [ "=", "!", "!*", "*" ],
+        :date => [ "=", ">=", "<=", "><", "<t+", ">t+", "><t+", "t+", "t", "ld", "w", "lw", "l2w", "m", "lm", "y", ">t-", "<t-", "><t-", "t-", "!*", "*" ],
+        :date_past => [ "=", ">=", "<=", "><", ">t-", "<t-", "><t-", "t-", "t", "ld", "w", "lw", "l2w", "m", "lm", "y", "!*", "*" ],
+        :string => [ "=", "~", "!", "!~", "!*", "*" ],
+        :text => [  "~", "!~", "!*", "*" ],
+        :integer => [ "=", ">=", "<=", "><", "!*", "*" ],
+        :float => [ "=", ">=", "<=", "><", "!*", "*" ]
+      }
+
+    # Returns a hash of localized labels for all filter operators
+    def self.operators_labels
+      operators.inject({}) {|h, operator| h[operator.first] = I18n.t(*operator.last); h}
+    end
+
+    def initialize(filters_for_class=nil,filters={})
+      @filters_for_class = filters_for_class
+      self.filters = filters
+    end
+
+    # Adds available filters
+    def initialize_available_filters
+      if @filters_for_class.is_a?(Class) && (@filters_for_class.superclass == ActiveRecord::Base)
+        associations = @filters_for_class.reflect_on_all_associations(:belongs_to)
+        association_foreign_keys = associations.map(&:foreign_key)
+        @filters_for_class.columns.each do |col|
+          case col.type
+          when :string
+            add_available_filter col.name, :type => :text
+          when :date
+            add_available_filter col.name, :type => :date
+          when :datetime
+            add_available_filter col.name, :type => :date_past
+          when :float
+            add_available_filter col.name, :type => :float
+          when :integer
+            if association_foreign_keys.include?(col.name)
+              association_class = associations.select { |a| a.foreign_key == col.name }.first.class_name.constantize
+              association_values = association_class.all.collect{|s| [s.to_s, s.id.to_s] }
+              add_available_filter col.name, :type => :list, :values => association_values
+            else
+              add_available_filter col.name, :type => :integer
+            end
+          when :boolean
+            add_available_filter col.name, :type => :list, :values => [["Yes","1"],["No", "0"]]
+          end # case
+        end # do
+      end
+    end
+    protected :initialize_available_filters
+
+    # Adds an available filter
+    def add_available_filter(field, options)
+      @available_filters ||= ActiveSupport::OrderedHash.new
+      @available_filters[field] = options
+      @available_filters
+    end
+
+    # Removes an available filter
+    def delete_available_filter(field)
+      if @available_filters
+        @available_filters.delete(field)
+      end
+    end
+
+    # Return a hash of available filters
+    def available_filters
+      unless @available_filters
+        initialize_available_filters
+        @available_filters.to_a.each do |field, options|
+          options[:name] ||= I18n.t("field_#{field}".gsub(/_id$/, ''))
+        end
+      end
+      @available_filters
+    end
+
+    def add_filter(field, operator, values=nil)
+      # values must be an array
+      return unless values.nil? || values.is_a?(Array)
+      # check if field is defined as an available filter
+      if available_filters.has_key? field
+        filter_options = available_filters[field]
+        filters[field] = {:operator => operator, :values => (values || [''])}
+      end
+    end
+
+    def add_short_filter(field, expression)
+      return unless expression && available_filters.has_key?(field)
+      field_type = available_filters[field][:type]
+      operators_by_filter_type[field_type].sort.reverse.detect do |operator|
+        next unless expression =~ /^#{Regexp.escape(operator)}(.*)$/
+        values = $1
+        add_filter field, operator, values.present? ? values.split('|') : ['']
+      end || add_filter(field, '=', expression.split('|'))
+    end
+
+    # Add multiple filters using +add_filter+
+    def add_filters(fields, operators, values)
+      if fields.is_a?(Array) && operators.is_a?(Hash) && (values.nil? || values.is_a?(Hash))
+        fields.each do |field|
+          add_filter(field, operators[field], values && values[field])
+        end
+      end
+    end
+
+    def has_filter?(field)
+      filters and filters[field]
+    end
+
+    def type_for(field)
+      available_filters[field][:type] if available_filters.has_key?(field)
+    end
+
+    def operator_for(field)
+      has_filter?(field) ? filters[field][:operator] : nil
+    end
+
+    def values_for(field)
+      has_filter?(field) ? filters[field][:values] : nil
+    end
+
+    def value_for(field, index=0)
+      (values_for(field) || [])[index]
+    end
+
+    def label_for(field)
+      label = available_filters[field][:name] if available_filters.has_key?(field)
+      label ||= l("field_#{field.to_s.gsub(/_id$/, '')}", :default => field)
+    end
+
+    # Returns a representation of the available filters for JSON serialization
+    def available_filters_as_json
+      json = {}
+      available_filters.to_a.each do |field, options|
+        json[field] = options.slice(:type, :name, :values).stringify_keys
+      end
+      json
+    end
+
+    def statement
+      # filters clauses
+      filters_clauses = []
+      filters.each_key do |field|
+        v = values_for(field).clone
+        next unless v and !v.empty?
+        operator = operator_for(field)
+
+        filters_clauses << '(' + sql_for_field(field, operator, v, @filters_for_class.table_name, field) + ')'
+      end if filters
+
+      filters_clauses.reject!(&:blank?)
+
+      filters_clauses.any? ? filters_clauses.join(' AND ') : nil
+    end
+
+
+    # Helper method to generate the WHERE sql for a +field+, +operator+ and a +value+
+    def sql_for_field(field, operator, value, db_table, db_field)
+      sql = ''
+      case operator
+      when "="
+        if value.any?
+          case type_for(field)
+          when :date, :date_past
+            sql = date_clause(db_table, db_field, parse_date(value.first), parse_date(value.first))
+          when :integer
+            sql = "#{db_table}.#{db_field} = #{value.first.to_i}"
+          when :float
+            sql = "#{db_table}.#{db_field} BETWEEN #{value.first.to_f - 1e-5} AND #{value.first.to_f + 1e-5}"
+          else
+            sql = "#{db_table}.#{db_field} IN (" + value.collect{|val| "'#{@filters_for_class.connection.quote_string(val)}'"}.join(",") + ")"
+          end
+        else
+          # IN an empty set
+          sql = "1=0"
+        end
+      when "!"
+        if value.any?
+          sql = "(#{db_table}.#{db_field} IS NULL OR #{db_table}.#{db_field} NOT IN (" + value.collect{|val| "'#{@filters_for_class.connection.quote_string(val)}'"}.join(",") + "))"
+        else
+          # NOT IN an empty set
+          sql = "1=1"
+        end
+      when "!*"
+        sql = "#{db_table}.#{db_field} IS NULL"
+      when "*"
+        sql = "#{db_table}.#{db_field} IS NOT NULL"
+      when ">="
+        if [:date, :date_past].include?(type_for(field))
+          sql = date_clause(db_table, db_field, parse_date(value.first), nil)
+        else
+          sql = "#{db_table}.#{db_field} >= #{value.first.to_f}"
+        end
+      when "<="
+        if [:date, :date_past].include?(type_for(field))
+          sql = date_clause(db_table, db_field, nil, parse_date(value.first))
+        else
+          sql = "#{db_table}.#{db_field} <= #{value.first.to_f}"
+        end
+      when "><"
+        if [:date, :date_past].include?(type_for(field))
+          sql = date_clause(db_table, db_field, parse_date(value[0]), parse_date(value[1]))
+        else
+          sql = "#{db_table}.#{db_field} BETWEEN #{value[0].to_f} AND #{value[1].to_f}"
+        end
+      when "><t-"
+        # between today - n days and today
+        sql = relative_date_clause(db_table, db_field, - value.first.to_i, 0)
+      when ">t-"
+        # >= today - n days
+        sql = relative_date_clause(db_table, db_field, - value.first.to_i, nil)
+      when "<t-"
+        # <= today - n days
+        sql = relative_date_clause(db_table, db_field, nil, - value.first.to_i)
+      when "t-"
+        # = n days in past
+        sql = relative_date_clause(db_table, db_field, - value.first.to_i, - value.first.to_i)
+      when "><t+"
+        # between today and today + n days
+        sql = relative_date_clause(db_table, db_field, 0, value.first.to_i)
+      when ">t+"
+        # >= today + n days
+        sql = relative_date_clause(db_table, db_field, value.first.to_i, nil)
+      when "<t+"
+        # <= today + n days
+        sql = relative_date_clause(db_table, db_field, nil, value.first.to_i)
+      when "t+"
+        # = today + n days
+        sql = relative_date_clause(db_table, db_field, value.first.to_i, value.first.to_i)
+      when "t"
+        # = today
+        sql = relative_date_clause(db_table, db_field, 0, 0)
+      when "ld"
+        # = yesterday
+        sql = relative_date_clause(db_table, db_field, -1, -1)
+      when "w"
+        # = this week
+        first_day_of_week = l(:general_first_day_of_week).to_i
+        day_of_week = Date.today.cwday
+        days_ago = (day_of_week >= first_day_of_week ? day_of_week - first_day_of_week : day_of_week + 7 - first_day_of_week)
+        sql = relative_date_clause(db_table, db_field, - days_ago, - days_ago + 6)
+      when "lw"
+        # = last week
+        first_day_of_week = l(:general_first_day_of_week).to_i
+        day_of_week = Date.today.cwday
+        days_ago = (day_of_week >= first_day_of_week ? day_of_week - first_day_of_week : day_of_week + 7 - first_day_of_week)
+        sql = relative_date_clause(db_table, db_field, - days_ago - 7, - days_ago - 1)
+      when "l2w"
+        # = last 2 weeks
+        first_day_of_week = l(:general_first_day_of_week).to_i
+        day_of_week = Date.today.cwday
+        days_ago = (day_of_week >= first_day_of_week ? day_of_week - first_day_of_week : day_of_week + 7 - first_day_of_week)
+        sql = relative_date_clause(db_table, db_field, - days_ago - 14, - days_ago - 1)
+      when "m"
+        # = this month
+        date = Date.today
+        sql = date_clause(db_table, db_field, date.beginning_of_month, date.end_of_month)
+      when "lm"
+        # = last month
+        date = Date.today.prev_month
+        sql = date_clause(db_table, db_field, date.beginning_of_month, date.end_of_month)
+      when "y"
+        # = this year
+        date = Date.today
+        sql = date_clause(db_table, db_field, date.beginning_of_year, date.end_of_year)
+      when "~"
+        sql = "LOWER(#{db_table}.#{db_field}) LIKE '%#{@filters_for_class.connection.quote_string(value.first.to_s.downcase)}%'"
+      when "!~"
+        sql = "LOWER(#{db_table}.#{db_field}) NOT LIKE '%#{@filters_for_class.connection.quote_string(value.first.to_s.downcase)}%'"
+      else
+        raise "Unknown query operator #{operator}"
+      end
+
+      return sql
+    end
+
+    # Returns a SQL clause for a date or datetime field.
+    def date_clause(table, field, from, to)
+      s = []
+      if from
+        if from.is_a?(Date)
+          from = Time.local(from.year, from.month, from.day).yesterday.end_of_day
+        else
+          from = from - 1 # second
+        end
+        if @filters_for_class.default_timezone == :utc
+          from = from.utc
+        end
+        s << ("#{table}.#{field} > '%s'" % [@filters_for_class.connection.quoted_date(from)])
+      end
+      if to
+        if to.is_a?(Date)
+          to = Time.local(to.year, to.month, to.day).end_of_day
+        end
+        if @filters_for_class.default_timezone == :utc
+          to = to.utc
+        end
+        s << ("#{table}.#{field} <= '%s'" % [@filters_for_class.connection.quoted_date(to)])
+      end
+      s.join(' AND ')
+    end
+
+    # Returns a SQL clause for a date or datetime field using relative dates.
+    def relative_date_clause(table, field, days_from, days_to)
+      date_clause(table, field, (days_from ? Date.today + days_from : nil), (days_to ? Date.today + days_to : nil))
+    end
+
+    # Returns a Date or Time from the given filter value
+    def parse_date(arg)
+      if arg.to_s =~ /\A\d{4}-\d{2}-\d{2}T/
+        Time.parse(arg) rescue nil
+      else
+        Date.parse(arg) rescue nil
+      end
+    end
+
+  end
+end

data/lib/turbo_filter/version.rb

@@ -1,3 +1,3 @@
 module TurboFilter
-  VERSION = "0.0.1"
+  VERSION = "1.0.1"
 end

data/lib/turbo_filter.rb

@@ -1,5 +1,13 @@
-require "turbo_filter/version"
+require 'turbo_filter/engine'
+require 'turbo_filter/version'
+require 'turbo_filter/turbo_filter_controller'
+require 'turbo_filter/turbo_filter_helper'
+require 'turbo_filter/turbo_filter_query'
+
+ActiveSupport.on_load(:action_view) do
+  ::ActionView::Base.send :include, TurboFilter::TurboFilterHelper
+end
+::ActionController::Base.send :include, TurboFilter::TurboFilterController
 
 module TurboFilter
-  # Your code goes here...
 end

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: turbo_filter
 version: !ruby/object:Gem::Version
-  version: 0.0.1
-  prerelease: 
+  version: 1.0.1
 platform: ruby
 authors:
 - Sandeep Kumar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-19 00:00:00.000000000 Z
+date: 2016-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -55,33 +50,39 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- app/assets/javascripts/turbo_filter.js
+- app/views/turbo_filters/_filters.html.erb
+- config/locales/en.yml
 - lib/turbo_filter.rb
+- lib/turbo_filter/engine.rb
+- lib/turbo_filter/turbo_filter_controller.rb
+- lib/turbo_filter/turbo_filter_helper.rb
+- lib/turbo_filter/turbo_filter_query.rb
 - lib/turbo_filter/version.rb
 - turbo_filter.gemspec
 homepage: ''
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23.2
+rubygems_version: 2.4.8
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Filter records
 test_files: []
 has_rdoc: