datagrid 1.0.0 → 1.0.1

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

data/app/assets/stylesheets/datagrid.css.sass

@@ -65,10 +65,6 @@ table.datagrid
   a
     float: left
 
-    &.dp-choose-date
-      margin-left: -22px
-      margin-top: 7px
-
   input[class*='filter']
     border: 2px solid #ccc
     border-radius: 4px

data/datagrid.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "datagrid"
-  s.version = "1.0.0"
+  s.version = "1.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bogdan Gusiev"]
-  s.date = "2013-09-19"
+  s.date = "2013-10-14"
   s.description = "This allows you to easily build datagrid aka data tables with sortable columns and filters"
   s.email = "agresso@gmail.com"
   s.extra_rdoc_files = [

data/lib/datagrid/column_names_attribute.rb

@@ -18,6 +18,17 @@ module Datagrid
 
     module ClassMethods
       # Adds a filter that acts like a column selection
+      # All defined columns will be available to select/deselect
+      # as a multi-select enum filter.
+      # Columns with <tt>:mandatory => true</tt> option
+      # will always present in the grid table and won't be listed
+      # in column names selection
+      # Accepts same options as <tt>:enum</tt> filter
+      #
+      # Examples:
+      # 
+      #   column_names_filter(:header => "Choose columns")
+      #   
       def column_names_filter(options = {})
         filter(:column_names, :enum, {
           :select => :optional_columns_select,

data/lib/datagrid/columns.rb

@@ -174,7 +174,7 @@ module Datagrid
       #   * <tt>column_names</tt> - list of column names if you want to limit data only to specified columns
       def rows(*column_names)
         #TODO: find in batches
-        self.assets.map do |asset|
+        driver.batch_map(assets) do |asset|
           self.row_for(asset, *column_names)
         end
       end
@@ -189,7 +189,7 @@ module Datagrid
       end
 
       # Return Array of Hashes where keys are column names and values are column values 
-      # for each row in datagrid <tt>#assets</tt>
+      # for each row in filtered datagrid relation.
       #
       # Example:
       #
@@ -205,7 +205,7 @@ module Datagrid
       #     MyGrid.new.data_hash # => [{:name => "One"}, {:name => "Two"}]
       #
       def data_hash
-        self.assets.map do |asset|
+        driver.batch_map(assets) do |asset|
           hash_for(asset)
         end
       end
@@ -268,12 +268,27 @@ module Datagrid
         self.columns(*names)
       end
 
-      # Finds a column by name
+      # Finds a column definition by name
       def column_by_name(name)
         self.class.column_by_name(name)
       end
 
 
+      # Gives ability to have a different formatting for CSV and HTML column value.
+      #
+      # Example:
+      #   
+      #   column(:name) do |model|
+      #     format(model.name) do |value|
+      #       content_tag(:strong, value)
+      #     end
+      #   end
+      #
+      #   column(:company) do |model|
+      #     format(model.company.name) do 
+      #       render :partial => "company_with_logo", :locals => {:company => model.company }
+      #     end
+      #   end
       def format(value, &block)
         if block_given?
           self.class.format(value, &block)

data/lib/datagrid/drivers/abstract_driver.rb

@@ -74,6 +74,14 @@ module Datagrid
         raise NotImplementedError
       end
 
+      def normalized_column_type(scope, field)
+        raise NotImplementedError
+      end
+
+      def batch_map(scope)
+        raise NotImplementedError
+      end
+
       protected
       def timestamp_class?(klass)
         TIMESTAMP_CLASSES.include?(klass)

data/lib/datagrid/drivers/active_record.rb

@@ -71,13 +71,31 @@ module Datagrid
       end
 
       def contains(scope, field, value)
-        if column_type(scope, field) == :string
-          field = prefix_table_name(scope, field)
-          scope.where("#{field} #{contains_predicate} ?", "%#{value}%")
-        else
-          # dont support contains operation by non-varchar column now
-          scope.where("1=0")
+        field = prefix_table_name(scope, field)
+        scope.where("#{field} #{contains_predicate} ?", "%#{value}%")
+      end
+
+      def normalized_column_type(scope, field)
+        type = column_type(scope, field)
+        return nil unless type
+        {
+          [:string, :text, :time, :binary] => :string,
+          [:integer, :primary_key] => :integer,
+          [:float, :decimal] => :float,
+          [:date] => :date,
+          [:datetime, :timestamp] => :timestamp,
+          [:boolean] => :boolean
+        }.each do |keys, value|
+          return value if keys.include?(type)
+        end
+      end
+
+      def batch_map(scope, &block)
+        result = []
+        scope.find_each do |record|
+          result << yield(record)
         end
+        result
       end
       
       protected

data/lib/datagrid/drivers/array.rb

@@ -64,6 +64,10 @@ module Datagrid
       def column_names(scope)
         []
       end
+
+      def batch_map(scope, &block)
+        scope.map(&block)
+      end
     end
   end
 end

data/lib/datagrid/drivers/mongo_mapper.rb

@@ -55,6 +55,10 @@ module Datagrid
       def column_names(scope)
         [] # TODO: implement support
       end
+
+      def batch_map(scope, &block)
+        scope.map(&block)
+      end
     end
   end
 end

data/lib/datagrid/drivers/mongoid.rb

@@ -52,12 +52,36 @@ module Datagrid
       end
 
       def contains(scope, field, value)
-        scope(field => Regexp.compile(Regexp.escape(value)))
+        scope.where(field => Regexp.compile(Regexp.escape(value)))
       end
 
       def column_names(scope)
         to_scope(scope).klass.fields.keys
       end
+
+      def normalized_column_type(scope, field)
+        type = to_scope(scope).klass.fields[field.to_s].try(:type)
+        return nil unless type
+        {
+          [BigDecimal , String, Symbol, Range, Array, Hash, ] => :string,
+          [Boolean] => :boolean,
+
+          [Date] => :date,
+
+          TIMESTAMP_CLASSES => :timestamp,
+
+          [Float] => :fload,
+
+          [Integer] => :integer,
+        }.each do |keys, value|
+          return value if keys.include?(type)
+        end
+        return :string
+      end
+
+      def batch_map(scope, &block)
+        scope.map(&block)
+      end
     end
   end
 end

data/lib/datagrid/filters.rb

@@ -55,24 +55,26 @@ module Datagrid
       # 
       # Arguments:
       #
-      #   * <tt>name</tt> - filter name
-      #   * <tt>type</tt> - filter type that defines type case and GUI representation of a filter
-      #   * <tt>options</tt> - hash of options
-      #   * <tt>block</tt> - proc to apply the filter
+      # * <tt>name</tt> - filter name
+      # * <tt>type</tt> - filter type that defines type case and GUI representation of a filter
+      # * <tt>options</tt> - hash of options
+      # * <tt>block</tt> - proc to apply the filter
       #
       # Available options:
       #   
-      #   * <tt>:header</tt> - determines the header of the filter
-      #   * <tt>:default</tt> - the default filter value. Able to accept a <tt>Proc</tt> in case default should be recalculated
-      #   * <tt>:multiple</tt> - determines if more than one option can be selected
-      #   * <tt>:allow_nil</tt> - determines if the value can be nil
-      #   * <tt>:allow_blank</tt> - determines if the value can be blank
-      #   * <tt>:before</tt> - determines the position of this filter, 
-      #     by adding it before the filter passed here (when using datagrid_form_for helper)
-      #   * <tt>:after</tt> - determines the position of this filter, 
-      #     by adding it after the filter passed here (when using datagrid_form_for helper)
-      #   * <tt>:dummy</tt> - if true, this filter will not be applied automatically 
-      #     and will just be displayed in form. In case you may want to apply it manually.
+      # * <tt>:header</tt> - determines the header of the filter
+      # * <tt>:default</tt> - the default filter value. Able to accept a <tt>Proc</tt> in case default should be recalculated
+      # * <tt>:multiple</tt> -  if true multiple values can be assigned to this filter. 
+      #   By default multiple values are parsed from string using `,` separator. 
+      #   But you can specify a different separator as option value. Default: false.
+      # * <tt>:allow_nil</tt> - determines if the value can be nil
+      # * <tt>:allow_blank</tt> - determines if the value can be blank
+      # * <tt>:before</tt> - determines the position of this filter, 
+      #   by adding it before the filter passed here (when using datagrid_form_for helper)
+      # * <tt>:after</tt> - determines the position of this filter, 
+      #   by adding it after the filter passed here (when using datagrid_form_for helper)
+      # * <tt>:dummy</tt> - if true, this filter will not be applied automatically 
+      #   and will be just displayed in form. In case you may want to apply it manually.
       #
       # See: https://github.com/bogdan/datagrid/wiki/Filters for examples
       def filter(name, type = :default, options = {}, &block)
@@ -121,7 +123,7 @@ module Datagrid
         self.class.filters
       end
 
-      # Returns filter valur for given filter definition
+      # Returns filter value for given filter definition
       def filter_value(filter)
         self[filter.name]
       end

data/lib/datagrid/filters/base_filter.rb

@@ -1,7 +1,7 @@
 class Datagrid::FilteringError < StandardError
 end
 
-class Datagrid::Filters::BaseFilter
+class Datagrid::Filters::BaseFilter #:nodoc:
 
   attr_accessor :grid_class, :options, :block, :name
 

data/lib/datagrid/filters/boolean_enum_filter.rb

@@ -1,4 +1,4 @@
-class Datagrid::Filters::BooleanEnumFilter < Datagrid::Filters::EnumFilter
+class Datagrid::Filters::BooleanEnumFilter < Datagrid::Filters::EnumFilter #:nodoc:
 
   YES = "YES"
   NO = "NO"

data/lib/datagrid/filters/boolean_filter.rb

@@ -1,5 +1,5 @@
 require "datagrid/utils"
-class Datagrid::Filters::BooleanFilter < Datagrid::Filters::BaseFilter
+class Datagrid::Filters::BooleanFilter < Datagrid::Filters::BaseFilter #:nodoc:
 
   def parse(value)
     Datagrid::Utils.booleanize(value)

data/lib/datagrid/filters/composite_filters.rb

@@ -1,6 +1,6 @@
 module Datagrid
   module Filters
-    module CompositeFilters
+    module CompositeFilters #:nodoc:
 
       def self.included(base)
         base.extend         ClassMethods

data/lib/datagrid/filters/date_filter.rb

@@ -12,26 +12,9 @@ class Datagrid::Filters::DateFilter < Datagrid::Filters::BaseFilter
   end
 
   def parse(value)
-    return nil if value.blank?
-    return value if value.is_a?(Range)
-    if value.is_a?(String)
-      formats.each do |format|
-        begin
-          return Date.strptime(value, format)
-        rescue ArgumentError
-        end
-      end
-    end
-    return value.to_date if value.respond_to?(:to_date)
-    return value unless value.is_a?(String)
-    Date.parse(value)
-  rescue ArgumentError
-    nil
+    Datagrid::Utils.parse_date(value)
   end
 
-  def formats
-    Array(Datagrid.configuration.date_formats)
-  end
 
   def format(value)
     if formats.any? && value
@@ -43,23 +26,15 @@ class Datagrid::Filters::DateFilter < Datagrid::Filters::BaseFilter
 
   def default_filter_where(driver, scope, value)
     if driver.is_timestamp?(scope, name)
-      value = format_value_timestamp(value)
+      value = Datagrid::Utils.format_date_as_timestamp(value)
     end
     super(driver, scope, value)
   end
 
   protected
-  def format_value_timestamp(value)
-    if !value
-      value
-    elsif (range? && value.is_a?(Array))
-      [value.first.try(:beginning_of_day), value.last.try(:end_of_day)]
-    elsif value.is_a?(Range)
-      (value.first.beginning_of_day..value.last.end_of_day)
-    else
-      value.beginning_of_day..value.end_of_day
-    end
-  end
 
+  def formats
+    Array(Datagrid.configuration.date_formats)
+  end
 end
 

data/lib/datagrid/filters/dynamic_filter.rb

@@ -6,12 +6,16 @@ class Datagrid::Filters::DynamicFilter < Datagrid::Filters::BaseFilter
 
   def initialize(*)
     super
-    options[:multiple] = true
     options[:select] ||= default_select
+    unless options.has_key?(:include_blank)
+      options[:include_blank] = false
+    end
   end
 
-  def parse(value)
-    value
+  def parse_values(filter)
+    field, operation, value = filter
+
+    [field, operation, type_cast(field, value)]
   end
 
   def unapplicable_value?(filter)
@@ -21,15 +25,31 @@ class Datagrid::Filters::DynamicFilter < Datagrid::Filters::BaseFilter
 
   def default_filter_where(driver, scope, filter)
     field, operation, value = filter
-    driver.to_scope(scope)
+    date_conversion = value.is_a?(Date) && driver.is_timestamp?(scope, field)
     case operation
     when '='
+      if date_conversion
+        value = Datagrid::Utils.format_date_as_timestamp(value)
+      end
       driver.where(scope, field, value)
     when '=~'
-      driver.contains(scope, field, value)
+      if column_type(field) == :string
+        driver.contains(scope, field, value)
+      else
+        if date_conversion
+          value = Datagrid::Utils.format_date_as_timestamp(value)
+        end
+        driver.where(scope, field, value)
+      end
     when '>='
+      if date_conversion
+        value = value.beginning_of_day
+      end
       driver.greater_equal(scope, field, value)
     when '<='
+      if date_conversion
+        value = value.end_of_day
+      end
       driver.less_equal(scope, field, value)
     else
       raise "unknown operation: #{operation.inspect}"
@@ -38,7 +58,7 @@ class Datagrid::Filters::DynamicFilter < Datagrid::Filters::BaseFilter
 
   def operations_select
     %w(= =~ >= <=).map do |operation|
-      I18n.t(operation, :scope => "datagrid.filters.dynamic.operations")
+      [I18n.t(operation, :scope => "datagrid.filters.dynamic.operations").html_safe, operation]
     end
   end
 
@@ -54,4 +74,30 @@ class Datagrid::Filters::DynamicFilter < Datagrid::Filters::BaseFilter
     }
   end
 
+  def type_cast(field, value)
+    type = column_type(field)
+    return nil if value.blank?
+    case type
+    when :string
+      value.to_s
+    when :integer
+      value.is_a?(Numeric) || value =~ /^\d/ ?  value.to_i : nil
+    when :float
+      value.is_a?(Numeric) || value =~ /^\d/ ?  value.to_f : nil
+    when :date
+      Datagrid::Utils.parse_date(value)
+    when :timestamp
+      Datagrid::Utils.parse_date(value)
+    when :boolean
+      Datagrid::Utils.booleanize(value)
+    when nil
+      value
+    else
+      raise NotImplementedError, "unknown column type: #{type.inspect}"
+    end
+  end
+
+  def column_type(field)
+    grid_class.driver.normalized_column_type(grid_class.scope, field)
+  end
 end

data/lib/datagrid/filters/enum_filter.rb

@@ -6,6 +6,9 @@ class Datagrid::Filters::EnumFilter < Datagrid::Filters::BaseFilter
 
   def initialize(*args)
     super(*args)
+    if checkboxes?
+      options[:multiple] = true
+    end
     raise Datagrid::ConfigurationError, ":select option not specified" unless options[:select]
   end
 
@@ -15,7 +18,11 @@ class Datagrid::Filters::EnumFilter < Datagrid::Filters::BaseFilter
   end
 
   def strict
-    self.options[:strict]
+    options[:strict]
+  end
+
+  def checkboxes?
+    options[:checkboxes]
   end
 
 end

data/lib/datagrid/form_builder.rb

@@ -22,7 +22,7 @@ module Datagrid
     end
 
     def datagrid_boolean_filter(attribute_or_filter, options = {})
-      check_box(datagrid_get_attribute(attribute_or_filter), options)
+      check_box(datagrid_get_attribute(attribute_or_filter), options.reverse_merge(datagrid_extra_checkbox_options))
     end
 
     def datagrid_date_filter(attribute_or_filter, options = {})
@@ -31,8 +31,7 @@ module Datagrid
 
     def datagrid_default_filter(attribute_or_filter, options = {})
       filter = datagrid_get_filter(attribute_or_filter)
-      value = object.filter_value_as_string(filter)
-      text_field filter.name, options.merge(:value => object.filter_value_as_string(filter))
+      text_field filter.name, options.reverse_merge(:value => object.filter_value_as_string(filter))
     end
 
     def datagrid_enum_filter(attribute_or_filter, options = {})
@@ -40,7 +39,16 @@ module Datagrid
       if !options.has_key?(:multiple) && filter.multiple?
         options[:multiple] = true
       end
-      select filter.name, filter.select(object) || [], {:include_blank => filter.include_blank, :prompt => filter.prompt, :include_hidden => false}, options
+      if filter.checkboxes?
+        filter.select(options).map do |element|
+          text, value = @template.send(:option_text_and_value, element)
+          id = [object_name, filter.name, value.underscore].join('_')
+          input = check_box(filter.name, options.merge(datagrid_extra_checkbox_options).reverse_merge(:id => id, :multiple => true), value, nil)
+          label(filter.name, input + text, :for => id)
+        end.join("\n").html_safe
+      else
+        select filter.name, filter.select(object) || [], {:include_blank => filter.include_blank, :prompt => filter.prompt, :include_hidden => false}, options
+      end
     end
 
     def datagrid_integer_filter(attribute_or_filter, options = {})
@@ -57,18 +65,18 @@ module Datagrid
       field, operation, value = object.filter_value(filter)
       options = options.merge(:name => input_name)
       field_input = select(
-        filter.name, 
-        filter.select(object) || [], 
+        filter.name,
+        filter.select(object) || [],
         {
           :include_blank => filter.include_blank,
           :prompt => filter.prompt,
           :include_hidden => false,
           :selected => field
-        }, 
+        },
         add_html_classes(options, "field")
       )
       operation_input = select(
-        filter.name, filter.operations_select, 
+        filter.name, filter.operations_select,
         {:include_blank => false, :include_hidden => false, :prompt => false, :selected => operation },
         add_html_classes(options, "operation")
       )
@@ -83,7 +91,7 @@ module Datagrid
 
 
         from_options = datagrid_range_filter_options(object, filter, :from, options)
-        to_options = datagrid_range_filter_options(object, filter, :to, options) 
+        to_options = datagrid_range_filter_options(object, filter, :to, options)
         # 2 inputs: "from date" and "to date" to specify a range
         [
           text_field(filter.name, from_options),
@@ -100,17 +108,17 @@ module Datagrid
       type_method_map = {:from => :first, :to => :last}
       options = add_html_classes(options, type)
       options[:value] = filter.format(object[filter.name].try(type_method_map[type]))
-      # In case of datagrid ranged filter 
+      # In case of datagrid ranged filter
       # from and to input will have same id
-      options[:id] = if !options.key?(:id) 
-         # Rails provides it's own default id for all inputs
-         # In order to prevent that we assign no id by default 
-        options[:id] = nil
-      elsif options[:id].present?
-        # If the id was given we prefix it
-        # with from_ and to_ accordingly
-        options[:id] = [type, options[:id]].join("_")
-      end
+      options[:id] = if !options.key?(:id)
+                       # Rails provides it's own default id for all inputs
+                       # In order to prevent that we assign no id by default
+                       options[:id] = nil
+                     elsif options[:id].present?
+                       # If the id was given we prefix it
+                       # with from_ and to_ accordingly
+                       options[:id] = [type, options[:id]].join("_")
+                     end
       options
     end
 
@@ -140,11 +148,16 @@ module Datagrid
     end
 
     def add_html_classes(options, *classes)
-      Datagrid::Utils.add_html_classes(options, *classes) 
+      Datagrid::Utils.add_html_classes(options, *classes)
+    end
+
+    def datagrid_extra_checkbox_options
+      ::ActionPack::VERSION::MAJOR >= 4 ? {:include_hidden => false} : {}
     end
 
     class Error < StandardError
     end
+
   end
 end
 

data/lib/datagrid/locale/en.yml

@@ -22,7 +22,7 @@ en:
         "no": "No"
       dynamic:
         operations:
-          ">=": ">="
-          "<=": "<="
+          ">=": "&ge;"
+          "<=": "&le;"
           "=": "="
-          "=~": "=~"
+          "=~": "&asymp;"

data/lib/datagrid/renderer.rb

@@ -38,7 +38,7 @@ module Datagrid
       options[:html] ||= {}
       options[:html][:class] ||= "datagrid #{html_class(grid)}"
       if options[:cycle]
-        ::Datagrid::Utils.warn_once("datagrid_table cycle option is deprecated. Use css to stylee odd/even rows instead.")
+        ::Datagrid::Utils.warn_once("datagrid_table cycle option is deprecated. Use css to style odd/even rows instead.")
       end
       assets = args.any? ? args.shift : grid.assets
       paginate = options[:paginate]

data/lib/datagrid/utils.rb

@@ -54,6 +54,37 @@ module Datagrid
         end
         block.call(*args)
       end
+
+      def parse_date(value)
+        return nil if value.blank?
+        return value if value.is_a?(Range)
+        if value.is_a?(String)
+          Array(Datagrid.configuration.date_formats).each do |format|
+            begin
+              return Date.strptime(value, format)
+            rescue ::ArgumentError
+            end
+          end
+        end
+        return Date.parse(value) if value.is_a?(String)
+        return value.to_date if value.respond_to?(:to_date)
+        value
+      rescue ::ArgumentError
+        nil
+      end
+
+      def format_date_as_timestamp(value)
+        if !value
+          value
+        elsif value.is_a?(Array)
+          [value.first.try(:beginning_of_day), value.last.try(:end_of_day)]
+        elsif value.is_a?(Range)
+          (value.first.beginning_of_day..value.last.end_of_day)
+        else
+          value.beginning_of_day..value.end_of_day
+        end
+      end
+
     end
   end
 end

data/spec/datagrid/filters/dynamic_filter_spec.rb

@@ -14,24 +14,109 @@ describe Datagrid::Filters::DynamicFilter do
     report.assets.should include(Entry.create!(:name => 'hello'))
     report.assets.should_not include(Entry.create!(:name => 'bye'))
   end
+
+  it "should support >= operation" do
+    report.condition = [:name, ">=", "d"]
+    report.assets.should include(Entry.create!(:name => 'x'))
+    report.assets.should include(Entry.create!(:name => 'd'))
+    report.assets.should_not include(Entry.create!(:name => 'a'))
+  end
+
   it "should blank value" do
     report.condition = [:name, "=", ""]
     report.assets.should include(Entry.create!(:name => 'hello'))
   end
-  it "should support =~ operation" do
+
+  it "should support =~ operation on strings" do
     report.condition = [:name, "=~", "ell"]
     report.assets.should include(Entry.create!(:name => 'hello'))
     report.assets.should_not include(Entry.create!(:name => 'bye'))
   end
-  it "should support >= operation" do
+
+  it "should support =~ operation integers" do
+    report.condition = [:group_id, "=~", 2]
+    report.assets.should include(Entry.create!(:group_id => 2))
+    report.assets.should_not include(Entry.create!(:group_id => 1))
+    report.assets.should_not include(Entry.create!(:group_id => 3))
+  end
+
+  it "should support >= operation on integer" do
     report.condition = [:group_id, ">=", 2]
     report.assets.should include(Entry.create!(:group_id => 3))
     report.assets.should_not include(Entry.create!(:group_id => 1))
   end
-  it "should support <= operation" do
+
+  it "should support <= operation on integer" do
     report.condition = [:group_id, "<=", 2]
     report.assets.should include(Entry.create!(:group_id => 1))
     report.assets.should_not include(Entry.create!(:group_id => 3))
   end
 
+  it "should support <= operation on integer with string value" do
+    report.condition = [:group_id, "<=", '2']
+    report.assets.should include(Entry.create!(:group_id => 1))
+    report.assets.should include(Entry.create!(:group_id => 2))
+    report.assets.should_not include(Entry.create!(:group_id => 3))
+  end
+
+  it "should nullify incorrect value for integer" do
+    report.condition = [:group_id, "<=", 'aa']
+    report.condition.should == [:group_id, "<=", nil]
+  end
+
+  it "should nullify incorrect value for date" do
+    report.condition = [:shipping_date, "<=", 'aa']
+    report.condition.should == [:shipping_date, "<=", nil]
+  end
+
+  it "should nullify incorrect value for datetime" do
+    report.condition = [:created_at, "<=", 'aa']
+    report.condition.should == [:created_at, "<=", nil]
+  end
+
+  it "should support date comparation operation by timestamp column" do
+    report.condition = [:created_at, "<=", '1986-08-05']
+    report.condition.should == [:created_at, "<=", Date.parse('1986-08-05')]
+    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-04 01:01:01')))
+    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
+    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:00')))
+    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-06 00:00:00')))
+    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
+  end
+
+  it "should support date = operation by timestamp column" do
+    report.condition = [:created_at, "=", '1986-08-05']
+    report.condition.should == [:created_at, "=", Date.parse('1986-08-05')]
+    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-04 23:59:59')))
+    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
+    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:01')))
+    #TODO: investigate SQLite issue and uncomment this line
+    #report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:00')))
+    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
+  end
+
+  it "should support date =~ operation by timestamp column" do
+    report.condition = [:created_at, "=~", '1986-08-05']
+    report.condition.should == [:created_at, "=~", Date.parse('1986-08-05')]
+    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-04 23:59:59')))
+    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 23:59:59')))
+    report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:01')))
+    #TODO: investigate SQLite issue and uncomment this line
+    #report.assets.should include(Entry.create!(:created_at => DateTime.parse('1986-08-05 00:00:00')))
+    report.assets.should_not include(Entry.create!(:created_at => DateTime.parse('1986-08-06 23:59:59')))
+  end
+
+  it "should support operations for invalid date" do
+    report.condition = [:shipping_date, "<=", '1986-08-05']
+    report.assets.should include(Entry.create!(:shipping_date => '1986-08-04'))
+    report.assets.should include(Entry.create!(:shipping_date => '1986-08-05'))
+    report.assets.should_not include(Entry.create!(:shipping_date => '1986-08-06'))
+  end
+  it "should support operations for invalid date" do
+    report.condition = [:shipping_date, "<=", Date.parse('1986-08-05')]
+    report.assets.should include(Entry.create!(:shipping_date => '1986-08-04'))
+    report.assets.should include(Entry.create!(:shipping_date => '1986-08-05'))
+    report.assets.should_not include(Entry.create!(:shipping_date => '1986-08-06'))
+  end
+
 end

data/spec/datagrid/filters/integer_filter_spec.rb

@@ -122,4 +122,23 @@ describe Datagrid::Filters::IntegerFilter do
     report.assets.should_not include(Entry.create!( :group_id => 3))
   end
   
+  it "should support multiple values" do
+    report = test_report(:group_id => "1,2") do
+      scope {Entry}
+      filter(:group_id, :string, :multiple => true)
+    end
+    report.assets.should include(Entry.create!( :group_id => 1))
+    report.assets.should include(Entry.create!( :group_id => 2))
+    report.assets.should_not include(Entry.create!( :group_id => 3))
+  end
+
+  it "should support custom separator multiple values" do
+    report = test_report(:group_id => "1|2") do
+      scope {Entry}
+      filter(:group_id, :string, :multiple => '|')
+    end
+    report.assets.should include(Entry.create!( :group_id => 1))
+    report.assets.should include(Entry.create!( :group_id => 2))
+    report.assets.should_not include(Entry.create!( :group_id => 3))
+  end
 end

data/spec/datagrid/filters/string_filter_spec.rb

@@ -20,6 +20,7 @@ describe Datagrid::Filters::StringFilter do
     report.assets.should include(Entry.create!( :name => "one,1"))
     report.assets.should include(Entry.create!( :name => "two,2"))
     report.assets.should_not include(Entry.create!( :name => "one"))
+    report.assets.should_not include(Entry.create!( :name => "two"))
   end
 
 end

data/spec/datagrid/form_builder_spec.rb

@@ -218,6 +218,29 @@ describe Datagrid::FormBuilder do
          <option value="second">second</option></select>'
         )}
       end
+      context "with checkboxes option" do
+        let(:_filter) { :category_with_prompt }
+        it { should equal_to_dom(
+          '<select class="category_with_prompt enum_filter" id="report_category_with_prompt" name="report[category_with_prompt]"><option value="">My Prompt</option>
+         <option value="first">first</option>
+         <option value="second">second</option></select>'
+        )}
+      end
+      context "with checkboxes option" do
+        let(:_grid) do
+          test_report do
+            scope {Entry}
+            filter(:category, :enum, :select => ["first", "second"], :checkboxes => true)
+          end
+        end
+        let(:_filter) { :category }
+        it { should equal_to_dom(
+          '
+<label for="report_category_first"><input class="category enum_filter" id="report_category_first" name="report[category][]" type="checkbox" value="first" />first</label>
+<label for="report_category_second"><input class="category enum_filter" id="report_category_second" name="report[category][]" type="checkbox" value="second" />second</label>
+'
+        )}
+      end
     end
 
     context "with eboolean filter type" do
@@ -373,9 +396,9 @@ describe Datagrid::FormBuilder do
          <option value="shipping_date">Shipping date</option>
          <option value="created_at">Created at</option>
          <option value="updated_at">Updated at</option></select><select class="condition dynamic_filter operation" id="report_condition" name="report[condition][]"><option value="=">=</option>
-         <option value="=~">=~</option>
-         <option value="&gt;=">&gt;=</option>
-         <option value="&lt;=">&lt;=</option></select><input class="condition dynamic_filter value" id="report_condition" name="report[condition][]" size="30" type="text">
+         <option value="=~">&asymp;</option>
+         <option value="&gt;=">&ge;</option>
+         <option value="&lt;=">&le;</option></select><input class="condition dynamic_filter value" id="report_condition" name="report[condition][]" size="30" type="text">
           HTML
         end
         it {should equal_to_dom(expected_html)}
@@ -389,9 +412,9 @@ describe Datagrid::FormBuilder do
           <<-HTML
             <select class="condition dynamic_filter field" id="report_condition" name="report[condition][]"><option value="id" selected>id</option>
        <option value="name">name</option></select><select class="condition dynamic_filter operation" id="report_condition" name="report[condition][]"><option value="=">=</option>
-       <option value="=~">=~</option>
-       <option value="&gt;=" selected>&gt;=</option>
-       <option value="&lt;=">&lt;=</option></select><input class="condition dynamic_filter value" id="report_condition" name="report[condition][]" size="30" type="text" value="1">
+       <option value="=~">&asymp;</option>
+       <option value="&gt;=" selected>&ge;</option>
+       <option value="&lt;=">&le;</option></select><input class="condition dynamic_filter value" id="report_condition" name="report[condition][]" size="30" type="text" value="1">
           HTML
         end
         it {should equal_to_dom(expected_html)}
@@ -405,9 +428,9 @@ describe Datagrid::FormBuilder do
           <<-HTML
         <select class="condition dynamic_filter field" id="report_condition" name="report[condition][]"><option value="id">id</option>
        <option value="name">name</option></select><select class="condition dynamic_filter operation" id="report_condition" name="report[condition][]"><option value="=">=</option>
-       <option value="=~">=~</option>
-       <option value="&gt;=">&gt;=</option>
-       <option value="&lt;=">&lt;=</option></select><input class="condition dynamic_filter value" id="report_condition" name="report[condition][]" size="30" type="text">
+       <option value="=~">&asymp;</option>
+       <option value="&gt;=">&ge;</option>
+       <option value="&lt;=">&le;</option></select><input class="condition dynamic_filter value" id="report_condition" name="report[condition][]" size="30" type="text">
           HTML
         end
         it {should equal_to_dom(expected_html)}

data/spec/spec_helper.rb

@@ -14,6 +14,7 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require "active_record"
 require 'action_view'
+require "rails"
 require "mongoid"
 require "mongo_mapper"
 require 'datagrid'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datagrid
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-19 00:00:00.000000000 Z
+date: 2013-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -344,7 +344,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2432952415509999407
+      hash: 1961249610796694956
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: