datagrid 1.8.2 → 2.0.0.pre.alpha

data/lib/datagrid/drivers/mongoid.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Datagrid
   module Drivers
     # @!visibility private
     class Mongoid < AbstractDriver
-
       def self.match?(scope)
         return false unless defined?(::Mongoid)
+
         if scope.is_a?(Class)
           scope.ancestors.include?(::Mongoid::Document)
         else
@@ -21,9 +23,7 @@ module Datagrid
       end
 
       def where(scope, attribute, value)
-        if value.is_a?(Range)
-          value = {"$gte" => value.first, "$lte" => value.last}
-        end
+        value = { "$gte" => value.first, "$lte" => value.last } if value.is_a?(Range)
         scope.where(attribute => value)
       end
 
@@ -36,18 +36,18 @@ module Datagrid
       end
 
       def default_order(scope, column_name)
-        has_column?(scope, column_name) ? column_name : nil
+        scope_has_column?(scope, column_name) ? column_name : nil
       end
 
       def greater_equal(scope, field, value)
-        scope.where(field => {"$gte" => value})
+        scope.where(field => { "$gte" => value })
       end
 
       def less_equal(scope, field, value)
-        scope.where(field => {"$lte" => value})
+        scope.where(field => { "$lte" => value })
       end
 
-      def has_column?(scope, column_name)
+      def scope_has_column?(scope, column_name)
         column_names(scope).include?(column_name.to_s)
       end
 
@@ -62,8 +62,9 @@ module Datagrid
       def normalized_column_type(scope, field)
         type = to_scope(scope).klass.fields[field.to_s]&.type
         return nil unless type
+
         {
-          [BigDecimal , String, Symbol, Range, Array, Hash, ] => :string,
+          [BigDecimal, String, Symbol, Range, Array, Hash] => :string,
           [::Mongoid::Boolean] => :boolean,
 
           [Date] => :date,
@@ -76,7 +77,7 @@ module Datagrid
         }.each do |keys, value|
           return value if keys.include?(type)
         end
-        return :string
+        :string
       end
 
       def batch_each(scope, batch_size, &block)
@@ -84,10 +85,9 @@ module Datagrid
         loop do
           batch = scope.skip(current_page * batch_size).limit(batch_size).to_a
           return if batch.empty?
-          scope.skip(current_page * batch_size).limit(batch_size).each do |item|
-            yield(item)
-          end
-          current_page+=1
+
+          scope.skip(current_page * batch_size).limit(batch_size).each(&block)
+          current_page += 1
         end
       end
 
@@ -100,10 +100,8 @@ module Datagrid
       end
 
       def can_preload?(scope, association)
-        !! scope.klass.reflect_on_association(association)
+        !!scope.klass.reflect_on_association(association)
       end
-
     end
   end
 end
-

data/lib/datagrid/drivers/sequel.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Datagrid
   module Drivers
     # @!visibility private
     class Sequel < AbstractDriver
-
       def self.match?(scope)
         return false unless defined?(::Sequel)
+
         if scope.is_a?(Class)
           scope.ancestors.include?(::Sequel::Model)
         else
@@ -14,11 +16,8 @@ module Datagrid
 
       def to_scope(scope)
         return scope if scope.is_a?(::Sequel::Dataset)
-        scope.where({})
-      end
 
-      def append_column_queries(assets, columns)
-        super
+        scope.where({})
       end
 
       def where(scope, attribute, value)
@@ -33,12 +32,8 @@ module Datagrid
         scope.order(::Sequel.desc(::Sequel.lit(order)))
       end
 
-      def reverse_order(scope)
-        super
-      end
-
       def default_order(scope, column_name)
-        has_column?(scope, column_name) ?  ::Sequel.lit(prefix_table_name(scope, column_name)) : nil
+        scope_has_column?(scope, column_name) ? ::Sequel.lit(prefix_table_name(scope, column_name)) : nil
       end
 
       def greater_equal(scope, field, value)
@@ -49,7 +44,7 @@ module Datagrid
         scope.where(::Sequel.lit("#{prefix_table_name(scope, field)} <= ?", value))
       end
 
-      def has_column?(scope, column_name)
+      def scope_has_column?(scope, column_name)
         scope.columns.include?(column_name.to_sym)
       end
 
@@ -65,13 +60,14 @@ module Datagrid
       def normalized_column_type(scope, field)
         type = column_type(scope, field)
         return nil unless type
+
         {
-          [:string, :blob, :time] => :string,
-          [:integer, :primary_key] => :integer,
-          [:float, :decimal] => :float,
+          %i[string blob time] => :string,
+          %i[integer primary_key] => :integer,
+          %i[float decimal] => :float,
           [:date] => :date,
           [:datetime] => :timestamp,
-          [:boolean] => :boolean
+          [:boolean] => :boolean,
         }.each do |keys, value|
           return value if keys.include?(type)
         end
@@ -96,18 +92,17 @@ module Datagrid
       end
 
       def can_preload?(scope, association)
-        !! scope.model.association_reflection(association)
+        !!scope.model.association_reflection(association)
       end
 
-
       protected
 
       def prefix_table_name(scope, field)
-        has_column?(scope, field) ?  [to_scope(scope).row_proc.table_name, field].join(".") : field
+        scope_has_column?(scope, field) ? [to_scope(scope).row_proc.table_name, field].join(".") : field
       end
 
       def column_type(scope, field)
-        has_column?(scope, field) ? to_scope(scope).row_proc.db_schema[field.to_sym][:type] : nil
+        scope_has_column?(scope, field) ? to_scope(scope).row_proc.db_schema[field.to_sym][:type] : nil
       end
     end
   end

data/lib/datagrid/drivers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "datagrid/drivers/abstract_driver"
 require "datagrid/drivers/active_record"
 require "datagrid/drivers/array"
@@ -5,7 +7,6 @@ require "datagrid/drivers/mongoid"
 require "datagrid/drivers/mongo_mapper"
 require "datagrid/drivers/sequel"
 
-
 module Datagrid
   # @!visibility private
   module Drivers

data/lib/datagrid/engine.rb

@@ -1,12 +1,20 @@
+# frozen_string_literal: true
+
 require "rails/engine"
+require "datagrid/helper"
+require "datagrid/form_builder"
 
 module Datagrid
-  # @!private
+  # @!visibility private
   class Engine < ::Rails::Engine
+    def self.extend_modules
+      ActionView::Base.include(Datagrid::Helper)
+      ActionView::Helpers::FormBuilder.include(Datagrid::FormBuilder)
+    end
+
     initializer "datagrid.helpers" do
-      #TODO: check why it doesn't work
       ActiveSupport.on_load :action_view do
-        include Datagrid::Helper
+        Engine.extend_modules
       end
     end
   end

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.begin, value.end]
-    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, true)
-      scope.public_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.begin&.beginning_of_day..value.end&.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
-