datagrid 0.9.3 → 1.0.0

data/lib/datagrid/drivers/abstract_driver.rb

@@ -66,6 +66,14 @@ module Datagrid
         raise NotImplementedError
       end
 
+      def contains(scope, field, value)
+        raise NotImplementedError
+      end
+
+      def column_names(scope)
+        raise NotImplementedError
+      end
+
       protected
       def timestamp_class?(klass)
         TIMESTAMP_CLASSES.include?(klass)

data/lib/datagrid/drivers/active_record.rb

@@ -40,6 +40,10 @@ module Datagrid
         scope.reorder(order).reverse_order
       end
 
+      def reverse_order(scope)
+        scope.reverse_order
+      end
+
       def default_order(scope, column_name)
         has_column?(scope, column_name) ? [scope.table_name, column_name].join(".") : nil
       end
@@ -58,8 +62,22 @@ module Datagrid
         false
       end
 
+      def column_names(scope)
+        scope.column_names
+      end
+
       def is_timestamp?(scope, field)
-        has_column?(scope, field) && scope.columns_hash[field.to_s].type == :datetime
+        column_type(scope, field) == :datetime
+      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")
+        end
       end
       
       protected
@@ -67,6 +85,16 @@ module Datagrid
       def prefix_table_name(scope, field)
         has_column?(scope, field) ?  [scope.table_name, field].join(".") : field
       end
+
+      def contains_predicate
+        defined?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) && 
+          ::ActiveRecord::Base.connection.is_a?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) ? 
+          'ilike' : 'like'
+      end
+
+      def column_type(scope, field)
+        has_column?(scope, field) ? scope.columns_hash[field.to_s].type : nil
+      end
     end
   end
 end

data/lib/datagrid/drivers/array.rb

@@ -34,13 +34,15 @@ module Datagrid
 
       def greater_equal(scope, field, value)
         scope.select do |object|
-          object.send(field) >= value
+          compare_value = object.send(field) 
+          compare_value.respond_to?(:>=) && compare_value >= value
         end
       end
 
       def less_equal(scope, field, value)
         scope.select do |object|
-          object.send(field) <= value
+          compare_value = object.send(field) 
+          compare_value.respond_to?(:<=) && compare_value <= value
         end
       end
 
@@ -52,6 +54,16 @@ module Datagrid
         has_column?(scope, column_name) && 
           timestamp_class?(scope.first.send(column_name).class)
       end
+
+      def contains(scope, field, value)
+        scope.select do |object|
+          object.send(field).to_s.include?(value)
+        end
+      end
+
+      def column_names(scope)
+        []
+      end
     end
   end
 end

data/lib/datagrid/drivers/mongo_mapper.rb

@@ -47,6 +47,14 @@ module Datagrid
         #TODO implement the support
         false
       end
+
+      def contains(scope, field, value)
+        scope(field => Regexp.compile(Regexp.escape(value)))
+      end
+
+      def column_names(scope)
+        [] # TODO: implement support
+      end
     end
   end
 end

data/lib/datagrid/drivers/mongoid.rb

@@ -43,13 +43,21 @@ module Datagrid
       end
 
       def has_column?(scope, column_name)
-        to_scope(scope).klass.fields.keys.include?(column_name.to_s)
+        column_names(scope).include?(column_name.to_s)
       end
 
       def is_timestamp?(scope, column_name)
         has_column?(scope, column_name) &&
           timestamp_class?(to_scope(scope).klass.fields[column_name.to_s].type)
       end
+
+      def contains(scope, field, value)
+        scope(field => Regexp.compile(Regexp.escape(value)))
+      end
+
+      def column_names(scope)
+        to_scope(scope).klass.fields.keys
+      end
     end
   end
 end

data/lib/datagrid/filters.rb

@@ -13,6 +13,7 @@ module Datagrid
     require "datagrid/filters/composite_filters"
     require "datagrid/filters/string_filter"
     require "datagrid/filters/float_filter"
+    require "datagrid/filters/dynamic_filter"
 
     FILTER_TYPES = {
       :date => Filters::DateFilter,
@@ -23,6 +24,7 @@ module Datagrid
       :integer => Filters::IntegerFilter,
       :enum => Filters::EnumFilter,
       :float => Filters::FloatFilter,
+      :dynamic => Filters::DynamicFilter
     }
 
     def self.included(base) #:nodoc:
@@ -72,7 +74,7 @@ module Datagrid
       #   * <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.
       #
-      # See: https://github.com/bogdan/datagrid/wiki/Columns for examples
+      # See: https://github.com/bogdan/datagrid/wiki/Filters for examples
       def filter(name, type = :default, options = {}, &block)
         if type.is_a?(Hash)
           options = type
@@ -111,11 +113,7 @@ module Datagrid
       end
 
       def assets # :nodoc:
-        result = super
-        self.class.filters.each do |filter|
-          result = filter.apply(self, result, filter_value(filter))
-        end
-        result
+        apply_filters(super, self.class.filters)
       end
 
       # Returns all defined filters Array
@@ -128,11 +126,31 @@ module Datagrid
         self[filter.name]
       end
 
+      # Returns string representation of filter value
+      def filter_value_as_string(filter)
+        value = filter_value(filter)
+        value = value.is_a?(Array) ?  value.join(filter.separator) : value.to_s
+        value.blank? ? nil : value
+      end
+
       # Returns filter object with the given name
       def filter_by_name(name)
         self.class.filter_by_name(name)
       end
 
+      # Returns assets filtered only by specified filters
+      # Allows partial filtering
+      def filter_by(*filters)
+        apply_filters(scope, filters.map{|f| filter_by_name(f)})
+      end
+
+      protected
+
+      def apply_filters(current_scope, filters)
+        filters.inject(current_scope) do |result, filter|
+          filter.apply(self, result, filter_value(filter))
+        end
+      end
     end # InstanceMethods
 
   end

data/lib/datagrid/filters/base_filter.rb

@@ -16,14 +16,15 @@ class Datagrid::Filters::BaseFilter
     raise NotImplementedError, "#parse(value) suppose to be overwritten"
   end
 
+
+  def unapplicable_value?(value)
+    value.nil? ? !allow_nil? : value.blank? && !allow_blank?
+  end
+
   def apply(grid_object, scope, value)
-    if value.nil?
-      return scope if !allow_nil?
-    else
-      return scope if value.blank? && !allow_blank?
-    end
+    return scope if unapplicable_value?(value)
 
-    result = execute(value, scope, grid_object, &block)
+    result = execute(value, scope, grid_object)
     return scope unless result
     unless grid_object.driver.match?(result)
       raise Datagrid::FilteringError, "Can not apply #{name.inspect} filter: result #{result.inspect} no longer match #{grid_object.driver.class}."
@@ -32,14 +33,20 @@ class Datagrid::Filters::BaseFilter
   end
 
   def parse_values(value)
-    if !self.multiple && value.is_a?(Array)
-      raise Datagrid::ArgumentError, "#{grid_class}##{name} filter can not accept Array argument. Use :multiple option."
-    end
-    values = Array.wrap(value)
-    values.map! do |v|
-      self.parse(v)
+    if multiple?
+      normalize_multiple_value(value).map do |v|
+        parse(v)
+      end
+    else
+      if value.is_a?(Array)
+        raise Datagrid::ArgumentError, "#{grid_class}##{name} filter can not accept Array argument. Use :multiple option."
+      end
+      parse(value)
     end
-    self.multiple ? values : values.first
+  end
+
+  def separator
+    options[:multiple].is_a?(String) ? options[:multiple] : default_separator
   end
 
   def header
@@ -53,6 +60,11 @@ class Datagrid::Filters::BaseFilter
   end
 
   def multiple
+    Datagrid::Utils.warn_once("Filter#multiple method is deprecated. Use Filter#multiple? instead")
+    multiple?
+  end
+
+  def multiple?
     self.options[:multiple]
   end
 
@@ -102,7 +114,7 @@ class Datagrid::Filters::BaseFilter
     driver.where(scope, name, value)
   end
 
-  def execute(value, scope, grid_object, &block)
+  def execute(value, scope, grid_object)
     if block.arity == 1
       scope.instance_exec(value, &block)
     else
@@ -110,5 +122,21 @@ class Datagrid::Filters::BaseFilter
     end
   end
 
+  def normalize_multiple_value(value)
+    case value
+    when String
+      #TODO: write tests and doc
+      value.split(separator)
+    when Array
+      value
+    else
+      Array.wrap(value)
+    end
+  end
+
+  def default_separator
+    ','
+  end
+
 end
 

data/lib/datagrid/filters/boolean_enum_filter.rb

@@ -5,7 +5,7 @@ class Datagrid::Filters::BooleanEnumFilter < Datagrid::Filters::EnumFilter
 
   def initialize(report, attribute, options = {}, &block)
     options[:select] = [YES, NO].map do |key, value|
-      [I18n.t("datagrid.filters.eboolean.#{key.downcase}", :default => key.humanize), key]
+      [I18n.t("datagrid.filters.eboolean.#{key.downcase}"), key]
     end
     super(report, attribute, options, &block)
   end

data/lib/datagrid/filters/dynamic_filter.rb

@@ -0,0 +1,57 @@
+require "datagrid/filters/select_options"
+
+class Datagrid::Filters::DynamicFilter < Datagrid::Filters::BaseFilter
+
+  include Datagrid::Filters::SelectOptions
+
+  def initialize(*)
+    super
+    options[:multiple] = true
+    options[:select] ||= default_select
+  end
+
+  def parse(value)
+    value
+  end
+
+  def unapplicable_value?(filter)
+    field, operation, value = filter
+    field.blank? || operation.blank? || super(value)
+  end
+
+  def default_filter_where(driver, scope, filter)
+    field, operation, value = filter
+    driver.to_scope(scope)
+    case operation
+    when '='
+      driver.where(scope, field, value)
+    when '=~'
+      driver.contains(scope, field, value)
+    when '>='
+      driver.greater_equal(scope, field, value)
+    when '<='
+      driver.less_equal(scope, field, value)
+    else
+      raise "unknown operation: #{operation.inspect}"
+    end
+  end
+
+  def operations_select
+    %w(= =~ >= <=).map do |operation|
+      I18n.t(operation, :scope => "datagrid.filters.dynamic.operations")
+    end
+  end
+
+  protected
+
+  def default_select
+    proc {|grid|
+      grid.driver.column_names(grid.scope).map do |name|
+        # Mongodb/Rails problem:
+        # '_id'.humanize returns ''
+        [name.gsub(/^_/, '').humanize.strip, name]
+      end
+    }
+  end
+
+end

data/lib/datagrid/filters/enum_filter.rb

@@ -1,5 +1,9 @@
+require "datagrid/filters/select_options"
+
 class Datagrid::Filters::EnumFilter < Datagrid::Filters::BaseFilter
 
+  include Datagrid::Filters::SelectOptions
+
   def initialize(*args)
     super(*args)
     raise Datagrid::ConfigurationError, ":select option not specified" unless options[:select]
@@ -10,27 +14,6 @@ class Datagrid::Filters::EnumFilter < Datagrid::Filters::BaseFilter
     value
   end
 
-  def select(object = nil)
-    select = self.options[:select]
-    if select.is_a?(Symbol)
-      object.send(select)
-    elsif select.respond_to?(:call)
-      Datagrid::Utils.apply_args(object, &select)
-    else
-      select
-    end
-  end
-
-  def include_blank
-    unless self.prompt
-      self.options.has_key?(:include_blank) ? options[:include_blank] : !multiple
-    end
-  end
-  
-  def prompt
-    self.options.has_key?(:prompt) ? options[:prompt] : false
-  end
-
   def strict
     self.options[:strict]
   end

data/lib/datagrid/filters/select_options.rb

@@ -0,0 +1,26 @@
+module Datagrid::Filters::SelectOptions
+
+  def select(object = nil)
+    #unless object
+      #Datagrid::Utils.warn_once("#{self.class.name}#select without argument is deprecated")
+    #end
+    select = self.options[:select]
+    if select.is_a?(Symbol)
+      object.send(select)
+    elsif select.respond_to?(:call)
+      Datagrid::Utils.apply_args(object, &select)
+    else
+      select
+    end
+  end
+
+  def include_blank
+    unless prompt
+      options.has_key?(:include_blank) ? options[:include_blank] : !multiple?
+    end
+  end
+  
+  def prompt
+    options.has_key?(:prompt) ? options[:prompt] : false
+  end
+end

data/lib/datagrid/form_builder.rb

@@ -3,12 +3,14 @@ require "action_view"
 module Datagrid
   module FormBuilder
 
+    # Returns a form input html for the corresponding filter name
     def datagrid_filter(filter_or_attribute, options = {})
       filter = datagrid_get_filter(filter_or_attribute)
-      options = Datagrid::Utils.add_html_classes(options, filter.name, datagrid_filter_html_class(filter))
+      options = add_html_classes(options, filter.name, datagrid_filter_html_class(filter))
       self.send(filter.form_builder_helper_name, filter, options)
     end
 
+    # Returns a form label html for the corresponding filter name
     def datagrid_label(filter_or_attribute, options = {})
       filter = datagrid_get_filter(filter_or_attribute)
       self.label(filter.name, filter.header, options)
@@ -28,25 +30,52 @@ module Datagrid
     end
 
     def datagrid_default_filter(attribute_or_filter, options = {})
-      text_field datagrid_get_attribute(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))
     end
 
     def datagrid_enum_filter(attribute_or_filter, options = {})
       filter = datagrid_get_filter(attribute_or_filter)
-      if !options.has_key?(:multiple) && filter.multiple
+      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}, options
+      select filter.name, filter.select(object) || [], {:include_blank => filter.include_blank, :prompt => filter.prompt, :include_hidden => false}, options
     end
 
     def datagrid_integer_filter(attribute_or_filter, options = {})
       filter = datagrid_get_filter(attribute_or_filter)
-      if filter.multiple && self.object[filter.name].blank?
+      if filter.multiple? && self.object[filter.name].blank?
         options[:value] = ""
       end
       datagrid_range_filter(:integer, filter, options)
     end
 
+    def datagrid_dynamic_filter(attribute_or_filter, options = {})
+      filter = datagrid_get_filter(attribute_or_filter)
+      input_name = "#{object_name}[#{filter.name.to_s}][]"
+      field, operation, value = object.filter_value(filter)
+      options = options.merge(:name => input_name)
+      field_input = select(
+        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, 
+        {:include_blank => false, :include_hidden => false, :prompt => false, :selected => operation },
+        add_html_classes(options, "operation")
+      )
+      value_input = text_field(filter.name, add_html_classes(options, "value").merge(:value => value))
+      [field_input, operation_input, value_input].join("\n").html_safe
+    end
+
     def datagrid_range_filter(type, attribute_or_filter, options = {})
       filter = datagrid_get_filter(attribute_or_filter)
       if filter.range?
@@ -58,18 +87,18 @@ module Datagrid
         # 2 inputs: "from date" and "to date" to specify a range
         [
           text_field(filter.name, from_options),
-          I18n.t("datagrid.misc.#{type}_range_separator", :default => "<span class=\"separator #{type}\"> - </span>"),
+          I18n.t("datagrid.filters.#{type}.range_separator"),
           text_field(filter.name, to_options)
         ].join.html_safe
       else
-        text_field(filter.name, options)
+        datagrid_default_filter(filter, options)
       end
     end
 
 
     def datagrid_range_filter_options(object, filter, type, options)
       type_method_map = {:from => :first, :to => :last}
-      options = Datagrid::Utils.add_html_classes(options, type)
+      options = add_html_classes(options, type)
       options[:value] = filter.format(object[filter.name].try(type_method_map[type]))
       # In case of datagrid ranged filter 
       # from and to input will have same id
@@ -110,6 +139,10 @@ module Datagrid
       filter.class.to_s.demodulize.underscore
     end
 
+    def add_html_classes(options, *classes)
+      Datagrid::Utils.add_html_classes(options, *classes) 
+    end
+
     class Error < StandardError
     end
   end