will_filter 5.1.0 → 5.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3792795c59de11d775d37d03afb2d497d9e845d2
-  data.tar.gz: 743f32488e08caf6d106f197132e7af9427b8c8f
+  metadata.gz: 9fe8cebd409b2e307d3720d1073ea9d6bd5f79d2
+  data.tar.gz: ae57f12d3fff3f71bfeb92fb6c2117e4fe314878
 SHA512:
-  metadata.gz: e53d62aa1a2dc8211b65a0bc41b77c9b35cc6935121621be0e8a5a56fd90786a376cffbed1566e9dac432c9e8301e03d1fe9a124319e76157f1fb767e515a084
-  data.tar.gz: '092323c5f9888b9f1878c56652917284594fbfaf2a248665ab71fbab769a3831aba1e9d21340708613f8f79edae16b77fd43cda807f249bfb42b8b2768a73997'
+  metadata.gz: 11dc83721d03a91f5c5c5b271850fd0714d96cf7b7c662969d3fd4819603cdcda8c3b64535d7229a3ef9e0a781e06bed62afa1be3ff946f43a2e2fe214b4a264
+  data.tar.gz: f266ee2c9b40ce0239792a014cc556237e687c8c6868ce31d10a8b15ca1ba43c5d187041ed2eec7e739ca1adfbc75cdd16cf8f6a89ce377174588e92dec823bf

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    will_filter (5.1.0)
+    will_filter (5.1.1)
       kaminari (~> 1.1)
       rails (~> 5.1)
       sass (~> 3.5)
@@ -213,4 +213,4 @@ DEPENDENCIES
   will_filter!
 
 BUNDLED WITH
-   1.15.3
+   1.15.4

data/lib/will_filter/containers/boolean.rb

@@ -33,20 +33,20 @@
 module WillFilter
   module Containers
     class Boolean < WillFilter::FilterContainer
-    
+
       def self.operators
         [:is]
       end
-    
+
       def selected?
-        value == "1"
+        value.to_s == '1'
       end
-    
+
       def sql_condition
         return [" #{condition.full_key} = ? ", (selected? ? true : false)] if operator == :is
       end
-      
-    end    
+
+    end
   end
 end
 

data/lib/will_filter/containers/date.rb

@@ -36,19 +36,19 @@ module WillFilter
       def self.operators
         [:is, :is_not, :is_after, :is_before]
       end
-    
+
       def validate
-        return "Value must be provided" if value.blank?
-        return "Value must be a valid date (2008-01-01)" if date.nil?
+        return 'Value must be provided' if value.blank?
+        return 'Value must be a valid date (2008-01-01)' if date.nil?
       end
-    
+
       def sql_condition
-        return [" #{condition.full_key} = ? ",  date]  if operator == :is
-        return [" #{condition.full_key} <> ? ", date]  if operator == :is_not
-        return [" #{condition.full_key} > ? ",  date]  if operator == :is_after
-        return [" #{condition.full_key} < ? ",  date]  if operator == :is_before
+        return [" #{condition.full_key} = ? ", date] if operator == :is
+        return [" #{condition.full_key} <> ? ", date] if operator == :is_not
+        return [" #{condition.full_key} > ? ", date] if operator == :is_after
+        return [" #{condition.full_key} < ? ", date] if operator == :is_before
       end
-      
+
     end
   end
 end

data/lib/will_filter/containers/date_range.rb

@@ -36,24 +36,24 @@ module WillFilter
       def self.operators
         [:is_in_the_range]
       end
-    
+
       def initialize(filter, criteria_key, operator, values)
         super(filter, criteria_key, operator, values)
         @start_date = values[0]
         @end_date = values[1] if values.size > 1
       end
-    
+
       def validate
         return "Start value must be provided" if @start_date.blank?
         return "Start value must be a valid date (2008-01-01)" if date(@start_date).nil?
         return "End value must be provided" if @end_date.blank?
         return "End value must be a valid date (2008-01-01)" if date(@end_date).nil?
       end
-    
+
       def sql_condition
         return [" (#{condition.full_key} >= ? and #{condition.full_key} <= ?) ", date(@start_date), date(@end_date)] if operator == :is_in_the_range
       end
-      
+
     end
   end
 end

data/lib/will_filter/containers/date_time.rb

@@ -36,17 +36,17 @@ module WillFilter
       def self.operators
         [:is, :is_not, :is_after, :is_before]
       end
-    
+
       def validate
-        return "Value must be provided" if value.blank?
-        return "Value must be a valid date/time (2008-01-01 14:30:00)" if time.nil?
+        return 'Value must be provided' if value.blank?
+        return 'Value must be a valid date/time (2008-01-01 14:30:00)' if time.nil?
       end
-    
+
       def sql_condition
-        return [" #{condition.full_key} = ? ",   time]     if operator == :is
-        return [" #{condition.full_key} <> ? ",  time]     if operator == :is_not
-        return [" #{condition.full_key} > ? ",   time]     if operator == :is_after
-        return [" #{condition.full_key} < ? ",   time]     if operator == :is_before
+        return [" #{condition.full_key} = ? ", time] if operator == :is
+        return [" #{condition.full_key} <> ? ", time] if operator == :is_not
+        return [" #{condition.full_key} > ? ", time] if operator == :is_after
+        return [" #{condition.full_key} < ? ", time] if operator == :is_before
       end
     end
   end

data/lib/will_filter/containers/date_time_range.rb

@@ -34,28 +34,28 @@ module WillFilter
   module Containers
     class DateTimeRange < WillFilter::FilterContainer
       attr_accessor :start_value, :end_value
-    
+
       def self.operators
         [:is_in_the_range]
       end
-    
+
       def initialize(filter, criteria_key, operator, values)
         super(filter, criteria_key, operator, values)
-    
+
         @start_value = values[0]
         @end_value = values[1] if values.size > 1
       end
-    
+
       def validate
         return "Start value must be provided" if start_value.blank?
         return "Start value must be a valid date/time (2008-01-01 14:30:00)" if time(start_value).nil?
         return "End value must be provided" if end_value.blank?
         return "End value must be a valid date/time (2008-01-01 14:30:00)" if time(end_value).nil?
       end
-    
+
       def sql_condition
         return [" (#{condition.full_key} >= ? and #{condition.full_key} <= ?) ", time(start_value), time(end_value)] if operator == :is_in_the_range
       end
     end
-  end 
+  end
 end

data/lib/will_filter/containers/double.rb

@@ -36,25 +36,25 @@ module WillFilter
       def self.operators
         [:is, :is_not, :is_less_than, :is_greater_than]
       end
-    
+
       def template_name
         'text'
       end
-    
+
       def numeric_value
         value.to_f
       end
-    
+
       def validate
         return "Value must be provided" if value.blank?
         return "Value must be a valid floating point number" unless is_floating_point?(value)
       end
-    
+
       def sql_condition
-        return [" #{condition.full_key} = ? ",   numeric_value]    if operator == :is
-        return [" #{condition.full_key} <> ? ",  numeric_value]    if operator == :is_not
-        return [" #{condition.full_key} < ? ",   numeric_value]    if operator == :is_less_than
-        return [" #{condition.full_key} > ? ",   numeric_value]    if operator == :is_greater_than
+        return [" #{condition.full_key} = ? ", numeric_value] if operator == :is
+        return [" #{condition.full_key} <> ? ", numeric_value] if operator == :is_not
+        return [" #{condition.full_key} < ? ", numeric_value] if operator == :is_less_than
+        return [" #{condition.full_key} > ? ", numeric_value] if operator == :is_greater_than
       end
     end
   end

data/lib/will_filter/containers/double_delimited.rb

@@ -33,24 +33,24 @@
 module WillFilter
   module Containers
     class DoubleDelimited < WillFilter::FilterContainer
-      NUMERIC_DELIMITER = ","   unless defined?(NUMERIC_DELIMITER)
-    
+      NUMERIC_DELIMITER = "," unless defined?(NUMERIC_DELIMITER)
+
       def self.operators
         [:is_in]
       end
-    
+
       def template_name
         'text'
       end
-    
+
       def validate
         return "Values must be provided. Separate values with '#{NUMERIC_DELIMITER}'" if value.blank?
       end
-    
+
       def split_values
-        value.split(NUMERIC_DELIMITER).collect{|v| v.strip.to_f}
+        value.split(NUMERIC_DELIMITER).collect {|v| v.strip.to_f}
       end
-    
+
       def sql_condition
         return [" #{condition.full_key} in (?) ", split_values] if operator == :is_in
       end

data/lib/will_filter/containers/double_range.rb

@@ -30,29 +30,30 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+
 module WillFilter
   module Containers
     class DoubleRange < WillFilter::FilterContainer
       attr_accessor :start_value, :end_value
-    
+
       def self.operators
         [:is_in_the_range]
       end
-    
+
       def initialize(filter, criteria_key, operator, values)
         super(filter, criteria_key, operator, values)
-    
+
         @start_value = values[0]
         @end_value = values[1] if values.size > 1
       end
-    
+
       def validate
-        return "Start value must be provided" 					if start_value.blank?
-        return "Start value must be a floating point number"  	unless is_floating_point?(start_value)
-        return "End value must be provided"   					if end_value.blank?
-        return "End value must be a floating point number"    	unless is_floating_point?(end_value)
+        return "Start value must be provided" if start_value.blank?
+        return "Start value must be a floating point number" unless is_floating_point?(start_value)
+        return "End value must be provided" if end_value.blank?
+        return "End value must be a floating point number" unless is_floating_point?(end_value)
       end
-    
+
       def template_name
         'numeric_range'
       end
@@ -60,11 +61,11 @@ module WillFilter
       def numeric_start_value
         start_value.to_f
       end
-    
+
       def numeric_end_value
         end_value.to_f
       end
-    
+
       def sql_condition
         return [" (#{condition.full_key} >= ? and #{condition.full_key} <= ?) ", numeric_start_value, numeric_end_value] if operator == :is_in_the_range
       end

data/lib/will_filter/containers/filter_list.rb

@@ -36,39 +36,34 @@ module WillFilter
       def self.operators
         [:is_filtered_by]
       end
-
+    
       def validate
         return "Value must be provided" if value.blank?
       end
-
+    
       def template_name
         'list'
       end
 
       def linked_filter
         @linked_filter ||= begin
-          model_class = filter.model_class_for_column_key(condition.key)
-
-          if model_class
-            model_class_name = model_class.name
-          elsif condition.key == :id
+          if condition.key == :id
             model_class_name = filter.model_class_name
           else
             model_class_name = condition.key.to_s[0..-4].camelcase
           end
-
           WillFilter::Filter.new(model_class_name)
         end
       end
-
+    
       def options
         linked_filter.saved_filters(false)
       end
-
+    
       def sql_condition
         return nil unless operator == :is_filtered_by
         sub_filter = WillFilter::Filter.find_by_id(value) || linked_filter.user_filters.first
-        return [""] unless sub_filter
+        return [''] unless sub_filter
 
         sub_conds = sub_filter.sql_conditions
 
@@ -76,7 +71,7 @@ module WillFilter
           sub_conds[0] = " #{condition.full_key} IN (SELECT #{sub_filter.table_name}.id FROM #{sub_filter.table_name}) "
         else
           sub_conds[0] = " #{condition.full_key} IN (SELECT #{sub_filter.table_name}.id FROM #{sub_filter.table_name} WHERE #{sub_conds[0]}) "
-        end
+        end  
 
         sub_conds
       end

data/lib/will_filter/containers/list.rb

@@ -36,7 +36,7 @@ module WillFilter
       def self.operators
         [:is, :is_not, :contains, :does_not_contain]
       end
-    
+
       def options
         opts = []
         filter.value_options_for(condition.key).each do |item|
@@ -52,14 +52,15 @@ module WillFilter
         end
         opts
       end
-    
+
       def sql_condition
-        return [" #{condition.full_key} = ? ", value]                if operator == :is
-        return [" #{condition.full_key} <> ? ", value]               if operator == :is_not
-        return [" #{condition.full_key} like ? ", "%#{value}%"]      if operator == :contains
-        return [" #{condition.full_key} not like ? ", "%#{value}%"]  if operator == :does_not_cotain
+        sanitized_value = value.to_s.downcase
+        return [" lower(#{condition.full_key}) = ? ", sanitized_value] if operator == :is
+        return [" lower(#{condition.full_key}) <> ? ", sanitized_value] if operator == :is_not
+        return [" lower(#{condition.full_key}) like ? ", "%#{sanitized_value}%"] if operator == :contains
+        return [" lower(#{condition.full_key}) not like ? ", "%#{sanitized_value}%"] if operator == :does_not_cotain
       end
-    
+
     end
   end
 end

data/lib/will_filter/containers/nil.rb

@@ -36,18 +36,18 @@ module WillFilter
       def self.operators
         [:is_provided, :is_not_provided]
       end
-    
+
       def template_name
         'blank'
       end
-    
+
       def validate
         # no validation is necessary
       end
-    
+
       def sql_condition
-        return [" #{condition.full_key} is not null "]  if operator == :is_provided
-        return [" #{condition.full_key} is null "]      if operator == :is_not_provided
+        return [" #{condition.full_key} is not null "] if operator == :is_provided
+        return [" #{condition.full_key} is null "] if operator == :is_not_provided
       end
     end
   end

data/lib/will_filter/containers/numeric.rb

@@ -36,25 +36,25 @@ module WillFilter
       def self.operators
         [:is, :is_not, :is_less_than, :is_greater_than]
       end
-    
+
       def template_name
         'text'
       end
-    
+
       def numeric_value
         value.to_i
       end
-    
+
       def validate
         return "Value must be provided" if value.blank?
         return "Value must be numeric" unless is_numeric?(value)
       end
-    
+
       def sql_condition
-        return [" #{condition.full_key} = ? ",   numeric_value]    if operator == :is
-        return [" #{condition.full_key} <> ? ",  numeric_value]    if operator == :is_not
-        return [" #{condition.full_key} < ? ",   numeric_value]    if operator == :is_less_than
-        return [" #{condition.full_key} > ? ",   numeric_value]    if operator == :is_greater_than
+        return [" #{condition.full_key} = ? ", numeric_value] if operator == :is
+        return [" #{condition.full_key} <> ? ", numeric_value] if operator == :is_not
+        return [" #{condition.full_key} < ? ", numeric_value] if operator == :is_less_than
+        return [" #{condition.full_key} > ? ", numeric_value] if operator == :is_greater_than
       end
     end
   end

data/lib/will_filter/containers/numeric_delimited.rb

@@ -33,24 +33,24 @@
 module WillFilter
   module Containers
     class NumericDelimited < WillFilter::FilterContainer
-      NUMERIC_DELIMITER = ","   unless defined?(NUMERIC_DELIMITER)
-    
+      NUMERIC_DELIMITER = "," unless defined?(NUMERIC_DELIMITER)
+
       def self.operators
         [:is_in]
       end
-    
+
       def template_name
         'text'
       end
-    
+
       def validate
         return "Values must be provided. Separate values with '#{NUMERIC_DELIMITER}'" if value.blank?
       end
-    
+
       def split_values
-        value.split(NUMERIC_DELIMITER).collect{|v| v.strip.to_i}
+        value.split(NUMERIC_DELIMITER).collect {|v| v.strip.to_i}
       end
-    
+
       def sql_condition
         return [" #{condition.full_key} in (?) ", split_values] if operator == :is_in
       end

data/lib/will_filter/containers/numeric_range.rb

@@ -34,33 +34,33 @@ module WillFilter
   module Containers
     class NumericRange < WillFilter::FilterContainer
       attr_accessor :start_value, :end_value
-    
+
       def self.operators
         [:is_in_the_range]
       end
-    
+
       def initialize(filter, criteria_key, operator, values)
         super(filter, criteria_key, operator, values)
-    
+
         @start_value = values[0]
         @end_value = values[1] if values.size > 1
       end
-    
+
       def validate
         return "Start value must be provided" if start_value.blank?
-        return "Start value must be numeric"  unless is_numeric?(start_value)
-        return "End value must be provided"   if end_value.blank?
-        return "End value must be numeric"    unless is_numeric?(end_value)
+        return "Start value must be numeric" unless is_numeric?(start_value)
+        return "End value must be provided" if end_value.blank?
+        return "End value must be numeric" unless is_numeric?(end_value)
       end
-    
+
       def numeric_start_value
         start_value.to_i
       end
-    
+
       def numeric_end_value
         end_value.to_i
       end
-    
+
       def sql_condition
         return [" (#{condition.full_key} >= ? and #{condition.full_key} <= ?) ", numeric_start_value, numeric_end_value] if operator == :is_in_the_range
       end

data/lib/will_filter/containers/single_date.rb

@@ -36,32 +36,31 @@ module WillFilter
       def self.operators
         [:is_on, :is_not_on]
       end
-    
+
       def template_name
         'date'
       end
-    
+
       def validate
         return "Value must be provided" if value.blank?
         return "Value must be a valid date (2008-01-01)" if start_date_time == nil
       end
-    
+
       def start_date_time
         @start_date_time ||= Time.parse(value)
       rescue ArgumentError
         nil
       end
-    
+
       def end_date_time
         (start_date_time + 1.day)
       rescue ArgumentError
         nil
       end
-    
+
       def sql_condition
-        return [' 1 = 0'] if time.nil?
-        return [" #{condition.full_key} >= ? and #{condition.full_key} < ? ", time, time + 1.day]  if operator == :is_on
-        return [" #{condition.full_key} < ? and #{condition.full_key} >= ? ", time, time + 1.day]  if operator == :is_not_on
+        return [" #{condition.full_key} >= ? and #{condition.full_key} < ? ", time, time + 1.day] if operator == :is_on
+        return [" #{condition.full_key} < ? and #{condition.full_key} >= ? ", time, time + 1.day] if operator == :is_not_on
       end
     end
   end

data/lib/will_filter/containers/text.rb

@@ -36,18 +36,19 @@ module WillFilter
       def self.operators
         [:is, :is_not, :contains, :does_not_contain, :starts_with, :ends_with]
       end
-    
+
       def validate
         # always valid, even when it is empty
       end
-    
+
       def sql_condition
-        return [" #{condition.full_key} = ? ", value]                 if operator == :is
-        return [" #{condition.full_key} <> ? ", value]                if operator == :is_not
-        return [" #{condition.full_key} like ? ", "%#{value}%"]       if operator == :contains
-        return [" #{condition.full_key} not like ? ", "%#{value}%"]   if operator == :does_not_contain
-        return [" #{condition.full_key} like ? ", "#{value}%"]        if operator == :starts_with
-        return [" #{condition.full_key} like ? ", "%#{value}"]        if operator == :ends_with
+        sanitized_value = value.to_s.downcase
+        return [" lower(#{condition.full_key}) = ? ", sanitized_value] if operator == :is
+        return [" lower(#{condition.full_key}) <> ? ", sanitized_value] if operator == :is_not
+        return [" lower(#{condition.full_key}) like ? ", "%#{sanitized_value}%"] if operator == :contains
+        return [" lower(#{condition.full_key}) not like ? ", "%#{sanitized_value}%"] if operator == :does_not_contain
+        return [" lower(#{condition.full_key}) like ? ", "#{sanitized_value}%"] if operator == :starts_with
+        return [" lower(#{condition.full_key}) like ? ", "%#{sanitized_value}"] if operator == :ends_with
       end
     end
   end

data/lib/will_filter/containers/text_delimited.rb

@@ -33,27 +33,28 @@
 module WillFilter
   module Containers
     class TextDelimited < WillFilter::FilterContainer
-      TEXT_DELIMITER = ","  unless defined?(TEXT_DELIMITER)
-    
+      TEXT_DELIMITER = "," unless defined?(TEXT_DELIMITER)
+
       def self.operators
         [:is_in, :is_not_in]
       end
-    
+
       def template_name
         'text'
       end
-    
+
       def validate
         return "Values must be provided. Separate values with '#{TEXT_DELIMITER}'" if value.blank?
       end
-    
+
       def split_values
-        value.to_s.split(TEXT_DELIMITER)
+        value.split(TEXT_DELIMITER)
       end
-    
+
       def sql_condition
-        return [" #{condition.full_key} in (?) ", split_values] if operator == :is_in
-        return [" #{condition.full_key} not in (?) ", split_values] if operator == :is_not_in
+        sanitized_values = split_values.collect {|val| val.to_s.downcase}
+        return [" lower(#{condition.full_key}) in (?) ", sanitized_values] if operator == :is_in
+        return [" lower(#{condition.full_key}) not in (?) ", sanitized_values] if operator == :is_not_in
       end
     end
   end

data/lib/will_filter/version.rb

@@ -31,5 +31,5 @@
 #++
 
 module WillFilter
-  VERSION = '5.1.0'
+  VERSION = '5.1.1'
 end