has_filter 0.1.0 → 0.1.1

data/CHANGELOG.md

@@ -1,8 +1,15 @@
-* 0.1.0
-  Rails 2.3 compatibility
-  `filtering` method become `filter`
-  Fix filtering with invalid params, now filter only model's attribute
-  Fix empty filtering
-
-* 0.0.1
-  Initial release
+## 0.1.1
+  * Fix nil filtering
+  * Fix boolean filtering
+
+
+## 0.1.0
+
+* Rails 2.3 compatibility
+* `filtering` method become `filter`
+*  Fix filtering with invalid params, now filter only model's attribute
+*  Fix empty filtering
+
+## 0.0.1
+
+*  Initial release

data/lib/has_filter.rb

@@ -15,66 +15,90 @@ module HasFilter
       conditions = filtering
       filters = []
 
-      conditions = conditions.select { |k, v| self.column_names.include? k.to_s }
-
-      if @_filters.present?
-        conditions = conditions.select { |key| @_filters.include? key }
-      end
+      conditions = _normalize_conditions(conditions)
 
       if conditions.empty?
-        filters << _hash_conditions(:id, nil)
+        filters << _hash_conditions(:id)
       else
         filters << _set_filters(conditions)
       end
 
-      filters = filters.flatten
-      find(:all, :conditions => filters)
+      find(:all, :conditions => filters.flatten)
     end
 
     private
 
-    def _hash_conditions(key, value)
-      if value.is_a? Array
-        ["#{key.to_s} in (:#{key.to_s})"]
-      else
-        ["#{key.to_s} = :#{key.to_s}"]
-      end
-    end
-
-    def _like_conditions(key, value)
-      if value.is_a? Array
-        ["#{key.to_s} in (:#{key.to_s})"]
-      else
-        ["#{key.to_s} like :#{key.to_s}"]
-      end
-    end
 
-    def _set_filters(filtering)
+    def _set_filters(conditions)
       filters = []
-      conditions = filtering
-      conditions.reject! { |k, v| v.nil? }
 
       conditions.each do |key, value|
         next if value.nil?
-        if self.columns_hash[key.to_s].type == :string
+        if _column_type(key) == :string
           filters << _like_conditions(key, value)
         else
           filters << _hash_conditions(key, value)
         end
       end
 
-      conditions = conditions.inject({}) do |hash, (key, value)|
-        if !value.is_a?(Array) && self.columns_hash[key.to_s].type == :string
-          hash[key.to_sym] = "%#{value}%"
-        elsif value.is_a?(Array)
-          hash[key.to_sym] = value.delete_if { |a| a.to_s.blank? }
+      [filters.join(" AND "), _bind_conditions(conditions)]
+    end
+
+    def _hash_conditions(key, value = nil)
+      return _join_condition(key, :in) if value.is_a? Array
+      _join_condition(key, :eq)
+    end
+
+    def _like_conditions(key, value)
+      return  _join_condition(key, :in) if value.is_a? Array
+      _join_condition(key, :like)
+    end
+
+    def _join_condition(key, kind)
+      types = { :in => "%s in (:%s)", :like => "%s like :%s", :eq => "%s = :%s" }
+      [types[kind] % [key.to_s, key.to_s]]
+    end
+
+    def _column_type(column)
+      self.columns_hash[column.to_s].type
+    end
+
+    def _to_bool(value)
+      ActiveRecord::ConnectionAdapters::Column.value_to_boolean(value)
+    end
+
+    def _normalize_column(key, value)
+      return _to_bool(value) if _column_type(key.to_s) == :boolean
+      value
+    end
+
+    def _normalize_conditions(filtering)
+      conditions = filtering
+      conditions = conditions.select { |k, v| self.column_names.include? k.to_s }
+      conditions = conditions.select { |k, v| @_filters.include? k              } if @_filters.present?
+      conditions = conditions.reject { |k, v| v && v.blank? || v.nil?           }
+
+      conditions.inject({})  do |hash, (key, value)|
+        key = key.to_sym
+
+        if value.is_a? Array
+          value.reject!  { |a| a.to_s.blank?             }
+          value.collect! { |v| _normalize_column(key, v) }
+          hash[key] = value
         else
-          hash[key.to_sym] = value
+          hash[key] = _normalize_column(key, value)
         end
+
         hash
       end
+    end
 
-      [filters.join(" AND "), conditions]
+    def _bind_conditions(conditions)
+      conditions.each do |key, value|
+        if !value.is_a?(Array) && _column_type(key) == :string
+          conditions[key] = "%#{value}%"
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: has_filter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-12 00:00:00.000000000 Z
+date: 2012-07-13 00:00:00.000000000 Z
 dependencies: []
 description: Active Record filter conditions
 email: