datagrid 1.8.1 → 2.0.0.pre.alpha

data/lib/datagrid/filters/dynamic_filter.rb

@@ -1,125 +1,171 @@
+# frozen_string_literal: true
+
 require "datagrid/filters/select_options"
 
-class Datagrid::Filters::DynamicFilter < Datagrid::Filters::BaseFilter
-
-  include Datagrid::Filters::SelectOptions
-
-  EQUAL_OPERATION = '='
-  LIKE_OPERATION = '=~'
-  MORE_EQUAL_OPERATION = '>='
-  LESS_EQUAL_OPERATION = '<='
-  DEFAULT_OPERATIONS = [
-    EQUAL_OPERATION,
-    LIKE_OPERATION,
-    MORE_EQUAL_OPERATION,
-    LESS_EQUAL_OPERATION,
-  ]
-  AVAILABLE_OPERATIONS = %w(= =~ >= <=)
-
-  def initialize(*)
-    super
-    options[:select] ||= default_select
-    options[:operations] ||= DEFAULT_OPERATIONS
-    unless options.has_key?(:include_blank)
-      options[:include_blank] = false
-    end
-  end
+module Datagrid
+  module Filters
+    class DynamicFilter < Datagrid::Filters::BaseFilter
+      include Datagrid::Filters::SelectOptions
 
-  def parse_values(filter)
-    field, operation, value = filter
+      EQUAL_OPERATION = "="
+      LIKE_OPERATION = "=~"
+      MORE_EQUAL_OPERATION = ">="
+      LESS_EQUAL_OPERATION = "<="
+      DEFAULT_OPERATIONS = [
+        EQUAL_OPERATION,
+        LIKE_OPERATION,
+        MORE_EQUAL_OPERATION,
+        LESS_EQUAL_OPERATION,
+      ].freeze
+      AVAILABLE_OPERATIONS = %w[= =~ >= <=].freeze
 
-    [field, operation, type_cast(field, value)]
-  end
+      def initialize(grid, name, **options, &block)
+        options[:select] ||= default_select
+        options[:operations] ||= DEFAULT_OPERATIONS
+        options[:include_blank] = false unless options.key?(:include_blank)
+        super
+      end
 
-  def unapplicable_value?(filter)
-    _, _, value = filter
-    super(value)
-  end
+      def default_input_options
+        { **super, type: nil }
+      end
 
-  def default_filter_where(scope, filter)
-    field, operation, value = filter
-    date_conversion = value.is_a?(Date) && driver.is_timestamp?(scope, field)
+      def parse_values(filter)
+        filter ? FilterValue.new(grid_class, filter) : nil
+      end
 
-    return scope if field.blank? || operation.blank?
-    unless operations.include?(operation)
-      raise Datagrid::FilteringError, "Unknown operation: #{operation.inspect}. Available operations: #{operations.join(' ')}"
-    end
-    case operation
-    when EQUAL_OPERATION
-      if date_conversion
-        value = Datagrid::Utils.format_date_as_timestamp(value)
+      def unapplicable_value?(filter)
+        super(filter&.value)
       end
-      driver.where(scope, field, value)
-    when LIKE_OPERATION
-      if column_type(field) == :string
-        driver.contains(scope, field, value)
-      else
-        if date_conversion
-          value = Datagrid::Utils.format_date_as_timestamp(value)
+
+      def default_filter_where(scope, filter)
+        field = filter.field
+        operation = filter.operation
+        value = filter.value
+        date_conversion = value.is_a?(Date) && driver.timestamp_column?(scope, field)
+
+        return scope if field.blank? || operation.blank?
+
+        unless operations.include?(operation)
+          raise Datagrid::FilteringError,
+            "Unknown operation: #{operation.inspect}. Available operations: #{operations.join(' ')}"
+        end
+
+        case operation
+        when EQUAL_OPERATION
+          value = Datagrid::Utils.format_date_as_timestamp(value) if date_conversion
+          driver.where(scope, field, value)
+        when LIKE_OPERATION
+          if column_type(field) == :string
+            driver.contains(scope, field, value)
+          else
+            value = Datagrid::Utils.format_date_as_timestamp(value) if date_conversion
+            driver.where(scope, field, value)
+          end
+        when MORE_EQUAL_OPERATION
+          value = value.beginning_of_day if date_conversion
+          driver.greater_equal(scope, field, value)
+        when LESS_EQUAL_OPERATION
+          value = value.end_of_day if date_conversion
+          driver.less_equal(scope, field, value)
+        else
+          raise Datagrid::FilteringError,
+            "Unknown operation: #{operation.inspect}. Use filter block argument to implement operation"
         end
-        driver.where(scope, field, value)
-      end
-    when MORE_EQUAL_OPERATION
-      if date_conversion
-        value = value.beginning_of_day
       end
-      driver.greater_equal(scope, field, value)
-    when LESS_EQUAL_OPERATION
-      if date_conversion
-        value = value.end_of_day
+
+      def operations
+        options[:operations]
       end
-      driver.less_equal(scope, field, value)
-    else
-      raise Datagrid::FilteringError, "Unknown operation: #{operation.inspect}. Use filter block argument to implement operation"
-    end
-  end
 
-  def operations
-    options[:operations]
-  end
+      def operations_select
+        operations.map do |operation|
+          [I18n.t(operation, scope: "datagrid.filters.dynamic.operations"), operation]
+        end
+      end
 
-  def operations_select
-    operations.map do |operation|
-      [I18n.t(operation, scope: "datagrid.filters.dynamic.operations").html_safe, operation]
-    end
-  end
+      protected
 
-  protected
+      def default_select
+        proc { |grid|
+          grid.driver.column_names(grid.scope).map do |name|
+            # Mongodb/Rails problem:
+            # '_id'.humanize returns ''
+            [name.gsub(%r{^_}, "").humanize.strip, name]
+          end
+        }
+      end
 
-  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]
+      def column_type(field)
+        grid_class.driver.normalized_column_type(grid_class.scope, field)
       end
-    }
-  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
+      class FilterValue
+        attr_accessor :field, :operation, :value
+
+        def initialize(grid_class, object = nil)
+          super()
+
+          case object
+          when Hash
+            object = object.symbolize_keys
+            self.field = object[:field]
+            self.operation = object[:operation]
+            self.value = object[:value]
+          when Array
+            self.field = object[0]
+            self.operation = object[1]
+            self.value = object[2]
+          else
+            raise ArgumentError, object.inspect
+          end
+          return unless grid_class
+
+          type = grid_class.driver.normalized_column_type(
+            grid_class.scope, field,
+          )
+          self.value = type_cast(type, value)
+        end
+
+        def inspect
+          { field: field, operation: operation, value: value }
+        end
 
-  def column_type(field)
-    grid_class.driver.normalized_column_type(grid_class.scope, field)
+        def to_ary
+          to_a
+        end
+
+        def to_a
+          [field, operation, value]
+        end
+
+        def to_h
+          { field: field, operation: operation, value: value }
+        end
+
+        protected
+
+        def type_cast(type, value)
+          return nil if value.blank?
+
+          case type
+          when :string
+            value.to_s
+          when :integer
+            value.is_a?(Numeric) || value =~ %r{^\d} ?  value.to_i : nil
+          when :float
+            value.is_a?(Numeric) || value =~ %r{^\d} ?  value.to_f : nil
+          when :date, :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
+      end
+    end
   end
 end

data/lib/datagrid/filters/enum_filter.rb

@@ -1,28 +1,52 @@
+# frozen_string_literal: true
+
 require "datagrid/filters/select_options"
 
-class Datagrid::Filters::EnumFilter < Datagrid::Filters::BaseFilter
+module Datagrid
+  module Filters
+    class EnumFilter < Datagrid::Filters::BaseFilter
+      include Datagrid::Filters::SelectOptions
 
-  include Datagrid::Filters::SelectOptions
+      # @!visibility private
+      def initialize(grid, name, **options, &block)
+        options[:multiple] = true if options[:checkboxes]
+        super
+        raise Datagrid::ConfigurationError, ":select option not specified" unless options[:select]
+      end
 
-  def initialize(*args)
-    super(*args)
-    if checkboxes?
-      options[:multiple] = true
-    end
-    raise Datagrid::ConfigurationError, ":select option not specified" unless options[:select]
-  end
+      def parse(value)
+        return nil if strict && !select.include?(value)
 
-  def parse(value)
-    return nil if self.strict && !select.include?(value)
-    value
-  end
+        value
+      end
 
-  def strict
-    options[:strict]
-  end
+      def default_input_options
+        {
+          **super,
+          type: enum_checkboxes? ? "checkbox" : "select",
+          multiple: multiple?,
+          include_hidden: enum_checkboxes? ? false : nil,
+        }
+      end
 
-  def checkboxes?
-    options[:checkboxes]
-  end
+      def label_options
+        if enum_checkboxes?
+          # Each checkbox has its own label
+          # The main label has no specific input to focus
+          # See app/views/datagrid/_enum_checkboxes.html.erb
+          { for: nil, **super }
+        else
+          super
+        end
+      end
+
+      def strict
+        options[:strict]
+      end
 
+      def enum_checkboxes?
+        options[:checkboxes]
+      end
+    end
+  end
 end

data/lib/datagrid/filters/extended_boolean_filter.rb

@@ -1,37 +1,49 @@
+# frozen_string_literal: true
+
 # @!visibility private
-class Datagrid::Filters::ExtendedBooleanFilter < Datagrid::Filters::EnumFilter
+module Datagrid
+  module Filters
+    class ExtendedBooleanFilter < Datagrid::Filters::EnumFilter
+      YES = "YES"
+      NO = "NO"
+      TRUTH_VALUES = [true, "true", "y", "yes"].freeze
+      FALSE_VALUES = [false, "false", "n", "no"].freeze
 
-  YES = "YES"
-  NO = "NO"
+      def initialize(*args, **options)
+        options[:select] = -> { boolean_select }
+        super
+      end
 
-  def initialize(report, attribute, options = {}, &block)
-    options[:select] = -> { boolean_select }
-    super(report, attribute, options, &block)
-  end
+      def execute(value, scope, grid_object)
+        value = value.blank? ? nil : ::Datagrid::Utils.booleanize(value)
+        super
+      end
 
-  def execute(value, scope, grid_object)
-    value = value.blank? ? nil : ::Datagrid::Utils.booleanize(value)
-    super(value, scope, grid_object)
-  end
+      def default_input_options
+        { **super, type: "select" }
+      end
 
-  def parse(value)
-    case
-    when value == true
-      YES
-    when value == false
-      NO
-    when value.blank?
-      nil
-    else
-      super(value)
-    end
-  end
+      def parse(value)
+        value = value.downcase if value.is_a?(String)
+        case value
+        when *TRUTH_VALUES
+          YES
+        when *FALSE_VALUES
+          NO
+        when value.blank?
+          nil
+        else
+          super
+        end
+      end
 
-  protected
+      protected
 
-  def boolean_select
-    [YES, NO].map do |key, value|
-      [I18n.t("datagrid.filters.xboolean.#{key.downcase}"), key]
+      def boolean_select
+        [YES, NO].map do |key, _value|
+          [I18n.t("datagrid.filters.xboolean.#{key.downcase}"), key]
+        end
+      end
     end
   end
 end

data/lib/datagrid/filters/float_filter.rb

@@ -1,9 +1,20 @@
-class Datagrid::Filters::FloatFilter < Datagrid::Filters::BaseFilter
+# frozen_string_literal: true
 
-  include Datagrid::Filters::RangedFilter
+# @!visibility private
+module Datagrid
+  module Filters
+    class FloatFilter < Datagrid::Filters::BaseFilter
+      include Datagrid::Filters::RangedFilter
 
-  def parse(value)
-    return nil if value.blank?
-    value.to_f
+      def default_input_options
+        { **super, type: "number", step: "any" }
+      end
+
+      def parse(value)
+        return nil if value.blank?
+
+        value.to_f
+      end
+    end
   end
 end

data/lib/datagrid/filters/integer_filter.rb

@@ -1,17 +1,28 @@
+# frozen_string_literal: true
+
 require "datagrid/filters/ranged_filter"
 
-class Datagrid::Filters::IntegerFilter < Datagrid::Filters::BaseFilter
+module Datagrid
+  module Filters
+    class IntegerFilter < Datagrid::Filters::BaseFilter
+      include Datagrid::Filters::RangedFilter
+
+      def default_input_options
+        { **super, type: "number", step: "1" }
+      end
 
-  include Datagrid::Filters::RangedFilter
+      def parse(value)
+        return nil if value.blank?
+        if defined?(ActiveRecord) && value.is_a?(ActiveRecord::Base) &&
+           value.respond_to?(:id) && value.id.is_a?(Integer)
+          return value.id
+        end
+        return value if value.is_a?(Range)
 
-  def parse(value)
-    return nil if value.blank?
-    if defined?(ActiveRecord) && value.is_a?(ActiveRecord::Base) &&
-        value.respond_to?(:id) && value.id.is_a?(Integer)
-      return value.id
+        return nil if value.to_i.zero? && value.is_a?(String) && value !~ %r{\A\s*-?0}
+
+        value.to_i
+      end
     end
-    return value if value.is_a?(Range)
-    value.to_i
   end
 end
-

data/lib/datagrid/filters/ranged_filter.rb

@@ -1,56 +1,77 @@
-module Datagrid::Filters::RangedFilter
+# frozen_string_literal: true
 
-  def initialize(grid, name, options, &block)
-    super(grid, name, options, &block)
-    if range?
-      options[:multiple] = true
-    end
-  end
+module Datagrid
+  module Filters
+    module RangedFilter
+      SERIALIZED_RANGE = %r{\A(.*)\.{2,3}(.*)\z}
 
-  def parse_values(value)
-    result = super(value)
-    return result if !range? || result.nil?
-    # Simulate single point range
-    return [result, result] unless result.is_a?(Array)
-
-    case result.size
-    when 0
-      nil
-    when 1
-      result.first
-    when 2
-      if result.first && result.last && result.first > result.last
-        # If wrong range is given - reverse it to be always valid
-        result.reverse
-      elsif !result.first && !result.last
-        nil
-      else
-        result
+      def parse_values(value)
+        return super unless range?
+
+        case value
+        when String
+          if ["..", "..."].include?(value)
+            nil
+          elsif (match = value.match(SERIALIZED_RANGE))
+            to_range(match.captures[0], match.captures[1], value.include?("..."))
+          else
+            super
+          end
+        when Hash
+          parse_hash(value)
+        when Array
+          parse_array(value)
+        when Range
+          to_range(value.begin, value.end)
+        else
+          result = super
+          to_range(result, result)
+        end
       end
-    else
-      raise ArgumentError, "Can not create a date range from array of more than two: #{result.inspect}"
-    end
 
-  end
+      def range?
+        options[:range]
+      end
 
-  def range?
-    options[:range]
-  end
+      def default_filter_where(scope, value)
+        if range? && value.is_a?(Range)
+          scope = driver.greater_equal(scope, name, value.begin) if value.begin
+          scope = driver.less_equal(scope, name, value.end) if value.end
+          scope
+        else
+          super
+        end
+      end
 
-  def default_filter_where(scope, value)
-    if range? && value.is_a?(Array)
-      left, right = value
-      if left
-        scope = driver.greater_equal(scope, name, left)
+      protected
+
+      def parse_hash(result)
+        to_range(result[:from] || result["from"], result[:to] || result["to"])
       end
-      if right
-        scope = driver.less_equal(scope, name, right)
+
+      def to_range(from, to, exclusive = false)
+        from = parse(from)
+        to = parse(to)
+        return nil unless to || from
+
+        # If wrong range is given - reverse it to be always valid
+        from, to = to, from if from && to && from > to
+        exclusive ? from...to : from..to
       end
-      scope
-    else
-      super(scope, value)
-    end
-  end
 
+      def parse_array(result)
+        first = result.first
+        last = result.last
 
+        case result.size
+        when 0
+          nil
+        when 1, 2
+          to_range(first, last)
+        else
+          raise ArgumentError, "Can not create a range from array of more than two elements"
+        end
+      end
+    end
+  end
 end