datagrid 1.8.1 → 2.0.0.pre.alpha

data/lib/datagrid/filters/base_filter.rb

@@ -1,184 +1,208 @@
+# frozen_string_literal: true
+
 # An error raise when datagrid filter is defined incorrectly and
 # causes filtering chain to be broken
-class Datagrid::FilteringError < StandardError
+module Datagrid
+  class FilteringError < StandardError
+  end
 end
 
 # @!visibility private
-class Datagrid::Filters::BaseFilter
+module Datagrid
+  module Filters
+    class BaseFilter
+      attr_accessor :grid_class, :options, :block, :name
+
+      def initialize(grid_class, name, **options, &block)
+        self.grid_class = grid_class
+        self.name = name.to_sym
+        self.options = options
+        self.block = block
+      end
 
-  class_attribute :input_helper_name, instance_writer: false
-  attr_accessor :grid_class, :options, :block, :name
+      def parse(value)
+        raise NotImplementedError, "#parse(value) suppose to be overwritten"
+      end
 
-  def initialize(grid_class, name, options = {}, &block)
-    self.grid_class = grid_class
-    self.name = name.to_sym
-    self.options = options
-    self.block = block || default_filter_block
-  end
+      def default_input_options
+        { type: "text" }
+      end
 
-  def parse(value)
-    raise NotImplementedError, "#parse(value) suppose to be overwritten"
-  end
+      def unapplicable_value?(value)
+        value.nil? ? !allow_nil? : value.blank? && !allow_blank?
+      end
 
-  def unapplicable_value?(value)
-    value.nil? ? !allow_nil? : value.blank? && !allow_blank?
-  end
+      def apply(grid_object, scope, value)
+        return scope if unapplicable_value?(value)
 
-  def apply(grid_object, scope, value)
-    return scope if unapplicable_value?(value)
+        result = execute(value, scope, grid_object)
 
-    result = execute(value, scope, grid_object)
+        return scope unless result
 
-    return scope unless result
-    if result == Datagrid::Filters::DEFAULT_FILTER_BLOCK
-      result = default_filter(value, scope, grid_object)
-    end
-    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}."
-    end
+        result = default_filter(value, scope) if result == Datagrid::Filters::DEFAULT_FILTER_BLOCK
+        unless grid_object.driver.match?(result)
+          raise(
+            Datagrid::FilteringError,
+            "Filter #{name.inspect} unapplicable: result no longer match #{grid_object.driver.class}.",
+          )
+        end
 
-    result
-  end
+        result
+      end
 
-  def parse_values(value)
-    if multiple?
-      return nil if value.nil?
-      normalize_multiple_value(value).map do |v|
-        parse(v)
+      def parse_values(value)
+        if multiple?
+          return nil if value.nil?
+
+          return normalize_multiple_value(value).map do |v|
+            parse(v)
+          end
+        end
+
+        case value
+        when Array
+          raise Datagrid::ArgumentError,
+            "#{grid_class}##{name} filter can not accept Array argument. Use :multiple option."
+        when Range
+          raise Datagrid::ArgumentError,
+            "#{grid_class}##{name} filter can not accept Range argument. Use :range option."
+        else
+          parse(value)
+        end
       end
-    elsif value.is_a?(Array)
-      raise Datagrid::ArgumentError, "#{grid_class}##{name} filter can not accept Array argument. Use :multiple option."
-    else
-      parse(value)
-    end
-  end
 
-  def separator
-    options[:multiple].is_a?(String) ? options[:multiple] : default_separator
-  end
+      def separator
+        options[:multiple].is_a?(String) ? options[:multiple] : default_separator
+      end
 
-  def header
-    if header = options[:header]
-      Datagrid::Utils.callable(header)
-    else
-      Datagrid::Utils.translate_from_namespace(:filters, grid_class, name)
-    end
-  end
+      def header
+        if (header = options[:header])
+          Datagrid::Utils.callable(header)
+        else
+          Datagrid::Utils.translate_from_namespace(:filters, grid_class, name)
+        end
+      end
 
-  def default(object)
-    default = self.options[:default]
-    if default.is_a?(Symbol)
-      object.send(default)
-    elsif default.respond_to?(:call)
-      Datagrid::Utils.apply_args(object, &default)
-    else
-      default
-    end
-  end
+      def default(object)
+        default = options[:default]
+        if default.is_a?(Symbol)
+          object.send(default)
+        elsif default.respond_to?(:call)
+          Datagrid::Utils.apply_args(object, &default)
+        else
+          default
+        end
+      end
 
-  def multiple?
-    self.options[:multiple]
-  end
+      def multiple?
+        options[:multiple]
+      end
 
-  def allow_nil?
-    options.has_key?(:allow_nil) ? options[:allow_nil] : options[:allow_blank]
-  end
+      def range?
+        false
+      end
 
-  def allow_blank?
-    options[:allow_blank]
-  end
+      def allow_nil?
+        options.key?(:allow_nil) ? options[:allow_nil] : options[:allow_blank]
+      end
 
-  def input_options
-    options[:input_options] || {}
-  end
+      def allow_blank?
+        options[:allow_blank]
+      end
 
-  def label_options
-    options[:label_options] || {}
-  end
+      def input_options
+        options[:input_options] || {}
+      end
 
-  def form_builder_helper_name
-    self.class.form_builder_helper_name
-  end
+      def label_options
+        options[:label_options] || {}
+      end
 
-  def self.form_builder_helper_name
-    :"datagrid_#{self.to_s.demodulize.underscore}"
-  end
+      def form_builder_helper_name
+        self.class.form_builder_helper_name
+      end
 
-  def default_filter_block
-    filter = self
-    lambda do |value, scope, grid|
-      filter.default_filter(value, scope, grid)
-    end
-  end
+      def self.form_builder_helper_name
+        :"datagrid_#{to_s.demodulize.underscore}"
+      end
 
-  def supports_range?
-    self.class.ancestors.include?(::Datagrid::Filters::RangedFilter)
-  end
+      def supports_range?
+        self.class.ancestors.include?(::Datagrid::Filters::RangedFilter)
+      end
 
-  def format(value)
-    value.nil? ? nil : value.to_s
-  end
+      def format(value)
+        value&.to_s
+      end
 
-  def dummy?
-    options[:dummy]
-  end
+      def dummy?
+        options[:dummy]
+      end
 
-  def type
-    Datagrid::Filters::FILTER_TYPES.each do |type, klass|
-      if is_a?(klass)
-        return type
+      def type
+        Datagrid::Filters::FILTER_TYPES.each do |type, klass|
+          return type if is_a?(klass)
+        end
+        raise "wtf is #{inspect}"
       end
-    end
-    raise "wtf is #{inspect}"
-  end
 
-  def enabled?(grid)
-    ::Datagrid::Utils.process_availability(grid, options[:if], options[:unless])
-  end
+      def enabled?(grid)
+        ::Datagrid::Utils.process_availability(grid, options[:if], options[:unless])
+      end
 
-  protected
+      def enum_checkboxes?
+        false
+      end
 
-  def default_filter_where(scope, value)
-    driver.where(scope, name, value)
-  end
+      def default_scope?
+        !block
+      end
 
-  def execute(value, scope, grid_object)
-    if block.arity == 1
-      scope.instance_exec(value, &block)
-    else
-      Datagrid::Utils.apply_args(value, scope, grid_object, &block)
-    end
-  end
+      protected
 
-  def normalize_multiple_value(value)
-    case value
-    when String
-      value.split(separator)
-    when Range
-      [value.first, value.last]
-    when Array
-      value
-    else
-      Array.wrap(value)
-    end
-  end
+      def default_filter_where(scope, value)
+        driver.where(scope, name, value)
+      end
 
-  def default_separator
-    ','
-  end
+      def execute(value, scope, grid_object)
+        if block&.arity == 1
+          scope.instance_exec(value, &block)
+        elsif block
+          Datagrid::Utils.apply_args(value, scope, grid_object, &block)
+        else
+          default_filter(value, scope)
+        end
+      end
 
-  def driver
-    grid_class.driver
-  end
+      def normalize_multiple_value(value)
+        case value
+        when String
+          value.split(separator)
+        when Range
+          [value.begin, value.end]
+        when Array
+          value
+        else
+          Array.wrap(value)
+        end
+      end
 
-  def default_filter(value, scope, grid)
-    return nil if dummy?
-    if !driver.has_column?(scope, name) && scope.respond_to?(name)
-      scope.send(name, value)
-    else
-      default_filter_where(scope, value)
+      def default_separator
+        ","
+      end
+
+      def driver
+        grid_class.driver
+      end
+
+      def default_filter(value, scope)
+        return nil if dummy?
+
+        if !driver.scope_has_column?(scope, name) && scope.respond_to?(name, true)
+          scope.public_send(name, value)
+        else
+          default_filter_where(scope, value)
+        end
+      end
     end
   end
-
 end
-

data/lib/datagrid/filters/boolean_filter.rb

@@ -1,9 +1,23 @@
+# frozen_string_literal: true
+
 require "datagrid/utils"
-# @!visibility private
-class Datagrid::Filters::BooleanFilter < Datagrid::Filters::BaseFilter
 
-  def parse(value)
-    Datagrid::Utils.booleanize(value)
-  end
+module Datagrid
+  module Filters
+    class BooleanFilter < Datagrid::Filters::BaseFilter
+      # @!visibility private
+      def initialize(grid, name, **opts)
+        super
+        options[:default] ||= false
+      end
 
+      def default_input_options
+        { **super, type: "checkbox" }
+      end
+
+      def parse(value)
+        Datagrid::Utils.booleanize(value)
+      end
+    end
+  end
 end

data/lib/datagrid/filters/date_filter.rb

@@ -1,40 +1,38 @@
-require "datagrid/filters/ranged_filter"
-
-class Datagrid::Filters::DateFilter < Datagrid::Filters::BaseFilter
-
-  include Datagrid::Filters::RangedFilter
-
-  def apply(grid_object, scope, value)
-    if value.is_a?(Range)
-      value = value.first.beginning_of_day..value.last.end_of_day
-    end
-    super(grid_object, scope, value)
-  end
-
-  def parse(value)
-    Datagrid::Utils.parse_date(value)
-  end
+# frozen_string_literal: true
 
+require "datagrid/filters/ranged_filter"
 
-  def format(value)
-    if formats.any? && value
-      value.strftime(formats.first)
-    else
-      super
-    end
-  end
-
-  def default_filter_where(scope, value)
-    if driver.is_timestamp?(scope, name)
-      value = Datagrid::Utils.format_date_as_timestamp(value)
+module Datagrid
+  module Filters
+    class DateFilter < Datagrid::Filters::BaseFilter
+      include Datagrid::Filters::RangedFilter
+
+      def default_input_options
+        { **super, type: "date" }
+      end
+
+      def apply(grid_object, scope, value)
+        value = Datagrid::Utils.format_date_as_timestamp(value) if grid_object.driver.timestamp_column?(scope, name)
+        super
+      end
+
+      def parse(value)
+        Datagrid::Utils.parse_date(value)
+      end
+
+      def format(value)
+        if formats.any? && value
+          value.strftime(formats.first)
+        else
+          super
+        end
+      end
+
+      protected
+
+      def formats
+        Array(Datagrid.configuration.date_formats)
+      end
     end
-    super(scope, value)
-  end
-
-  protected
-
-  def formats
-    Array(Datagrid.configuration.date_formats)
   end
 end
-

data/lib/datagrid/filters/date_time_filter.rb

@@ -1,25 +1,33 @@
+# frozen_string_literal: true
+
 require "datagrid/filters/ranged_filter"
 
-class Datagrid::Filters::DateTimeFilter < Datagrid::Filters::BaseFilter
+module Datagrid
+  module Filters
+    class DateTimeFilter < Datagrid::Filters::BaseFilter
+      include Datagrid::Filters::RangedFilter
 
-  include Datagrid::Filters::RangedFilter
+      def default_input_options
+        { **super, type: "datetime-local" }
+      end
 
-  def parse(value)
-    Datagrid::Utils.parse_datetime(value)
-  end
+      def parse(value)
+        Datagrid::Utils.parse_datetime(value)
+      end
 
-  def format(value)
-    if formats.any? && value
-      value.strftime(formats.first)
-    else
-      super
-    end
-  end
+      def format(value)
+        if formats.any? && value
+          value.strftime(formats.first)
+        else
+          super
+        end
+      end
 
-  protected
+      protected
 
-  def formats
-    Array(Datagrid.configuration.datetime_formats)
+      def formats
+        Array(Datagrid.configuration.datetime_formats)
+      end
+    end
   end
 end
-

data/lib/datagrid/filters/default_filter.rb

@@ -1,5 +1,11 @@
-class Datagrid::Filters::DefaultFilter < Datagrid::Filters::BaseFilter
-  def parse(value)
-    value
+# frozen_string_literal: true
+
+module Datagrid
+  module Filters
+    class DefaultFilter < Datagrid::Filters::BaseFilter
+      def parse(value)
+        value
+      end
+    end
   end
 end