datagrid 1.8.1 → 1.8.2

data/lib/datagrid/core.rb

@@ -1,26 +1,20 @@
 require "datagrid/drivers"
 require "active_support/core_ext/class/attribute"
+require "active_model/attribute_assignment"
 
 module Datagrid
   module Core
+    include ::ActiveModel::AttributeAssignment
 
     # @!visibility private
     def self.included(base)
       base.extend ClassMethods
       base.class_eval do
         class_attribute :scope_value
-
-        class_attribute :datagrid_attributes, instance_writer: false
-        self.datagrid_attributes = []
-
+        class_attribute :datagrid_attributes, instance_writer: false, default: []
         class_attribute :dynamic_block, instance_writer: false
-        class_attribute :forbidden_attributes_protection, instance_writer: false
-        self.forbidden_attributes_protection = false
-        if defined?(::ActiveModel::AttributeAssignment)
-          include ::ActiveModel::AttributeAssignment
-        end
+        class_attribute :forbidden_attributes_protection, instance_writer: false, default: false
       end
-      base.include InstanceMethods
     end
 
     module ClassMethods
@@ -129,150 +123,155 @@ module Datagrid
 
     end
 
-    module InstanceMethods
-
-      def initialize(attributes = nil, &block)
-        super()
-
-        if attributes
-          self.attributes = attributes
-        end
+    def initialize(attributes = nil, &block)
+      super()
 
-        instance_eval(&dynamic_block) if dynamic_block
-        if block_given?
-          self.scope(&block)
-        end
+      if attributes
+        self.attributes = attributes
       end
 
-      # @return [Hash<Symbol, Object>] grid attributes including filter values and ordering values
-      def attributes
-        result = {}
-        self.datagrid_attributes.each do |name|
-          result[name] = self[name]
-        end
-        result
+      instance_eval(&dynamic_block) if dynamic_block
+      if block_given?
+        self.scope(&block)
       end
+    end
 
-      # @return [Object] Any datagrid attribute value
-      def [](attribute)
-        self.send(attribute)
-      end
 
-      # Assigns any datagrid attribute
-      # @param attribute [Symbol, String] Datagrid attribute name
-      # @param value [Object] Datagrid attribute value
-      # @return [void]
-      def []=(attribute, value)
-        self.send(:"#{attribute}=", value)
+    # @return [Hash<Symbol, Object>] grid attributes including filter values and ordering values
+    def attributes
+      result = {}
+      self.datagrid_attributes.each do |name|
+        result[name] = self[name]
       end
+      result
+    end
 
-      # @return [Object] a scope relation (e.g ActiveRecord::Relation) with all applied filters
-      def assets
-        scope
-      end
+    # Updates datagrid attributes with a passed hash argument
+    # @param attributes [Hash<Symbol, Object>]
+    # @example
+    #   grid = MyGrid.new
+    #   grid.attributes = {first_name: 'John', last_name: 'Smith'}
+    #   grid.first_name # => 'John'
+    #   grid.last_name # => 'Smith'
+    def attributes=(attributes)
+      super(attributes)
+    end
 
-      # Updates datagrid attributes with a passed hash argument
-      def attributes=(attributes)
-        if respond_to?(:assign_attributes)
-          if !forbidden_attributes_protection && attributes.respond_to?(:permit!)
-            attributes.permit!
-          end
-          assign_attributes(attributes)
-        else
-          attributes.each do |name, value|
-            self[name] = value
-          end
-          self
-        end
-      end
+    # @return [Object] Any datagrid attribute value
+    def [](attribute)
+      self.public_send(attribute)
+    end
 
-      # Returns serializable query arguments skipping all nil values
-      # @example
-      #   grid = ProductsGrid.new(category: 'dresses', available: true)
-      #   grid.as_query # => {category: 'dresses', available: true}
-      def as_query
-        attributes = self.attributes.clone
-        attributes.each do |key, value|
-          attributes.delete(key) if value.nil?
-        end
-        attributes
-      end
+    # Assigns any datagrid attribute
+    # @param attribute [Symbol, String] Datagrid attribute name
+    # @param value [Object] Datagrid attribute value
+    # @return [void]
+    def []=(attribute, value)
+      self.public_send(:"#{attribute}=", value)
+    end
 
-      # @return [Hash<Symbol, Hash<Symbol, Object>>] query parameters to link this grid from a page
-      # @example
-      #   grid = ProductsGrid.new(category: 'dresses', available: true)
-      #   Rails.application.routes.url_helpers.products_path(grid.query_params)
-      #     # => "/products?products_grid[category]=dresses&products_grid[available]=true"
-      def query_params(attributes = {})
-        { param_name.to_sym => as_query.merge(attributes) }
-      end
+    # @return [Object] a scope relation (e.g ActiveRecord::Relation) with all applied filters
+    def assets
+      scope
+    end
 
-      # Redefines scope at instance level
-      # @example
-      #   class MyGrid
-      #     scope { Article.order('created_at desc') }
-      #   end
-      #
-      #   grid = MyGrid.new
-      #   grid.scope do |scope|
-      #     scope.where(author_id: current_user.id)
-      #   end
-      #   grid.assets
-      #       # => SELECT * FROM articles WHERE author_id = ?
-      #       #    ORDER BY created_at desc
-      def scope(&block)
-        if block_given?
-          current_scope = scope
-          self.scope_value = proc {
-            Datagrid::Utils.apply_args(current_scope, &block)
-          }
-          self
-        else
-          scope = original_scope
-          driver.to_scope(scope)
-        end
+    # Returns serializable query arguments skipping all nil values
+    # @example
+    #   grid = ProductsGrid.new(category: 'dresses', available: true)
+    #   grid.as_query # => {category: 'dresses', available: true}
+    def as_query
+      attributes = self.attributes.clone
+      attributes.each do |key, value|
+        attributes.delete(key) if value.nil?
       end
+      attributes
+    end
 
-      # @!visibility private
-      def original_scope
-        check_scope_defined!
-        scope_value.call
-      end
+    # @return [Hash<Symbol, Hash<Symbol, Object>>] query parameters to link this grid from a page
+    # @example
+    #   grid = ProductsGrid.new(category: 'dresses', available: true)
+    #   Rails.application.routes.url_helpers.products_path(grid.query_params)
+    #     # => "/products?products_grid[category]=dresses&products_grid[available]=true"
+    def query_params(attributes = {})
+      { param_name.to_sym => as_query.merge(attributes) }
+    end
 
-      # Resets current instance scope to default scope defined in a class
-      # @return [void]
-      def reset_scope
-        self.scope_value = self.class.scope_value
+    # Redefines scope at instance level
+    # @example
+    #   class MyGrid
+    #     scope { Article.order('created_at desc') }
+    #   end
+    #
+    #   grid = MyGrid.new
+    #   grid.scope do |scope|
+    #     scope.where(author_id: current_user.id)
+    #   end
+    #   grid.assets
+    #       # => SELECT * FROM articles WHERE author_id = ?
+    #       #    ORDER BY created_at desc
+    def scope(&block)
+      if block_given?
+        current_scope = scope
+        self.scope_value = proc {
+          Datagrid::Utils.apply_args(current_scope, &block)
+        }
+        self
+      else
+        scope = original_scope
+        driver.to_scope(scope)
       end
+    end
 
-      # @return [Boolean] true if the scope was redefined for this instance of grid object
-      def redefined_scope?
-        self.class.scope_value != scope_value
-      end
+    # @!visibility private
+    def original_scope
+      check_scope_defined!
+      scope_value.call
+    end
 
-      # @!visibility private
-      def driver
-        self.class.driver
-      end
+    # Resets current instance scope to default scope defined in a class
+    # @return [void]
+    def reset_scope
+      self.scope_value = self.class.scope_value
+    end
 
-      # @!visibility private
-      def check_scope_defined!(message = nil)
-        self.class.send :check_scope_defined!, message
-      end
+    # @return [Boolean] true if the scope was redefined for this instance of grid object
+    def redefined_scope?
+      self.class.scope_value != scope_value
+    end
 
-      # @return [String] a datagrid attributes and their values in inspection form
-      def inspect
-        attrs = attributes.map do |key, value|
-          "#{key}: #{value.inspect}"
-        end.join(", ")
-        "#<#{self.class} #{attrs}>"
-      end
+    # @!visibility private
+    def driver
+      self.class.driver
+    end
 
-      def ==(other)
-        self.class == other.class &&
-          attributes == other.attributes &&
-          scope == other.scope
-      end
+    # @!visibility private
+    def check_scope_defined!(message = nil)
+      self.class.send :check_scope_defined!, message
+    end
+
+    # @return [String] a datagrid attributes and their values in inspection form
+    def inspect
+      attrs = attributes.map do |key, value|
+        "#{key}: #{value.inspect}"
+      end.join(", ")
+      "#<#{self.class} #{attrs}>"
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        attributes == other.attributes &&
+        scope == other.scope
+    end
+
+    # Resets loaded assets and column values cache
+    # @return [void]
+    def reset
+      assets.reset
+    end
+
+    protected
+    def sanitize_for_mass_assignment(attributes)
+      forbidden_attributes_protection ? super(attributes) : attributes
     end
   end
 end

data/lib/datagrid/drivers/abstract_driver.rb

@@ -5,11 +5,10 @@ module Datagrid
 
       TIMESTAMP_CLASSES = [DateTime, Time, ActiveSupport::TimeWithZone]
 
-      class_attribute :subclasses
+      class_attribute :subclasses, default: []
 
       def self.inherited(base)
         super(base)
-        self.subclasses ||= []
         self.subclasses << base
       end
 

data/lib/datagrid/drivers/array.rb

@@ -4,7 +4,10 @@ module Datagrid
     class Array < AbstractDriver
 
       def self.match?(scope)
-        !Datagrid::Drivers::ActiveRecord.match?(scope) && (scope.is_a?(::Array) || scope.is_a?(Enumerator))
+        !Datagrid::Drivers::ActiveRecord.match?(scope) && (
+          scope.is_a?(::Array) || scope.is_a?(Enumerator) ||
+          (defined?(::ActiveRecord::Result) && scope.is_a?(::ActiveRecord::Result))
+        )
       end
 
       def to_scope(scope)
@@ -13,7 +16,7 @@ module Datagrid
 
       def where(scope, attribute, value)
         scope.select do |object|
-          object.send(attribute) == value
+          object.public_send(attribute) == value
         end
       end
 
@@ -21,7 +24,7 @@ module Datagrid
         return scope unless order
         return scope if order.empty?
         scope.sort_by do |object|
-          object.send(order)
+          object.public_send(order)
         end
       end
 
@@ -39,15 +42,13 @@ module Datagrid
 
       def greater_equal(scope, field, value)
         scope.select do |object|
-          compare_value = object.send(field)
-          compare_value.respond_to?(:>=) && compare_value >= value
+          object.public_send(field) >= value
         end
       end
 
       def less_equal(scope, field, value)
         scope.select do |object|
-          compare_value = object.send(field)
-          compare_value.respond_to?(:<=) && compare_value <= value
+          object.public_send(field) <= value
         end
       end
 
@@ -57,12 +58,12 @@ module Datagrid
 
       def is_timestamp?(scope, column_name)
         has_column?(scope, column_name) &&
-          timestamp_class?(scope.first.send(column_name).class)
+          timestamp_class?(scope.first.public_send(column_name).class)
       end
 
       def contains(scope, field, value)
         scope.select do |object|
-          object.send(field).to_s.include?(value)
+          object.public_send(field).to_s.include?(value)
         end
       end
 

data/lib/datagrid/drivers/mongoid.rb

@@ -60,7 +60,7 @@ module Datagrid
       end
 
       def normalized_column_type(scope, field)
-        type = to_scope(scope).klass.fields[field.to_s].try(:type)
+        type = to_scope(scope).klass.fields[field.to_s]&.type
         return nil unless type
         {
           [BigDecimal , String, Symbol, Range, Array, Hash, ] => :string,

data/lib/datagrid/filters/base_filter.rb

@@ -155,7 +155,7 @@ class Datagrid::Filters::BaseFilter
     when String
       value.split(separator)
     when Range
-      [value.first, value.last]
+      [value.begin, value.end]
     when Array
       value
     else
@@ -173,8 +173,8 @@ class Datagrid::Filters::BaseFilter
 
   def default_filter(value, scope, grid)
     return nil if dummy?
-    if !driver.has_column?(scope, name) && scope.respond_to?(name)
-      scope.send(name, value)
+    if !driver.has_column?(scope, name) && scope.respond_to?(name, true)
+      scope.public_send(name, value)
     else
       default_filter_where(scope, value)
     end

data/lib/datagrid/filters/date_filter.rb

@@ -6,7 +6,7 @@ class Datagrid::Filters::DateFilter < Datagrid::Filters::BaseFilter
 
   def apply(grid_object, scope, value)
     if value.is_a?(Range)
-      value = value.first.beginning_of_day..value.last.end_of_day
+      value = value.begin&.beginning_of_day..value.end&.end_of_day
     end
     super(grid_object, scope, value)
   end

data/lib/datagrid/filters/extended_boolean_filter.rb

@@ -3,6 +3,8 @@ class Datagrid::Filters::ExtendedBooleanFilter < Datagrid::Filters::EnumFilter
 
   YES = "YES"
   NO = "NO"
+  TRUTH_VALUES = [true, 'true', "y", "yes"]
+  FALSE_VALUES = [false, 'false', "n", "no"]
 
   def initialize(report, attribute, options = {}, &block)
     options[:select] = -> { boolean_select }
@@ -15,10 +17,11 @@ class Datagrid::Filters::ExtendedBooleanFilter < Datagrid::Filters::EnumFilter
   end
 
   def parse(value)
-    case
-    when value == true
+    value = value.downcase if value.is_a?(String)
+    case value
+    when *TRUTH_VALUES
       YES
-    when value == false
+    when *FALSE_VALUES
       NO
     when value.blank?
       nil

data/lib/datagrid/filters.rb

@@ -38,11 +38,9 @@ module Datagrid
 
         include Datagrid::Core
         include Datagrid::Filters::CompositeFilters
-        class_attribute :filters_array
-        self.filters_array = []
+        class_attribute :filters_array, default: []
 
       end
-      base.include InstanceMethods
     end
 
     module ClassMethods
@@ -138,94 +136,91 @@ module Datagrid
       end
     end
 
-    module InstanceMethods
 
-      # @!visibility private
-      def initialize(*args, &block)
-        self.filters_array = self.class.filters_array.clone
-        self.filters_array.each do |filter|
-          self[filter.name] = filter.default(self)
-        end
-        super(*args, &block)
+    # @!visibility private
+    def initialize(*args, &block)
+      self.filters_array = self.class.filters_array.clone
+      self.filters_array.each do |filter|
+        self[filter.name] = filter.default(self)
       end
+      super(*args, &block)
+    end
 
-      # @!visibility private
-      def assets
-        apply_filters(super, filters)
-      end
+    # @!visibility private
+    def assets
+      apply_filters(super, filters)
+    end
 
-      # Returns filter value for given filter definition
-      def filter_value(filter)
-        self[filter.name]
-      end
+    # Returns filter value for given filter definition
+    def filter_value(filter)
+      self[filter.name]
+    end
 
-      # Returns string representation of filter value
-      def filter_value_as_string(name)
-        filter = filter_by_name(name)
-        value = filter_value(filter)
-        if value.is_a?(Array)
-          value.map {|v| filter.format(v) }.join(filter.separator)
-        else
-          filter.format(value)
-        end
+    # Returns string representation of filter value
+    def filter_value_as_string(name)
+      filter = filter_by_name(name)
+      value = filter_value(filter)
+      if value.is_a?(Array)
+        value.map {|v| filter.format(v) }.join(filter.separator)
+      else
+        filter.format(value)
       end
+    end
 
-      # Returns filter object with the given name
-      def filter_by_name(name)
-        self.class.filter_by_name(name)
-      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
+    # 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
 
-      # Returns select options for specific filter or filter name
-      # If given filter doesn't support select options raises `ArgumentError`
-      def select_options(filter)
-        find_select_filter(filter).select(self)
-      end
+    # Returns select options for specific filter or filter name
+    # If given filter doesn't support select options raises `ArgumentError`
+    def select_options(filter)
+      find_select_filter(filter).select(self)
+    end
 
-      # Sets all options as selected for a filter that has options
-      def select_all(filter)
-        filter = find_select_filter(filter)
-        self[filter.name] = select_values(filter)
-      end
+    # Sets all options as selected for a filter that has options
+    def select_all(filter)
+      filter = find_select_filter(filter)
+      self[filter.name] = select_values(filter)
+    end
 
-      # Returns all values that can be set to a filter with select options
-      def select_values(filter)
-        find_select_filter(filter).select_values(self)
-      end
+    # Returns all values that can be set to a filter with select options
+    def select_values(filter)
+      find_select_filter(filter).select_values(self)
+    end
 
-      def default_filter
-        self.class.default_filter
-      end
+    def default_filter
+      self.class.default_filter
+    end
 
-      # Returns all currently enabled filters
-      def filters
-        self.class.filters.select do |filter|
-          filter.enabled?(self)
-        end
+    # Returns all currently enabled filters
+    def filters
+      self.class.filters.select do |filter|
+        filter.enabled?(self)
       end
+    end
 
-      protected
+    protected
 
-      def find_select_filter(filter)
-        filter = filter_by_name(filter)
-        unless filter.class.included_modules.include?(::Datagrid::Filters::SelectOptions)
-          raise ::Datagrid::ArgumentError,
-            "#{self.class.name}##{filter.name} with type #{FILTER_TYPES.invert[filter.class].inspect} can not have select options"
-        end
-        filter
+    def find_select_filter(filter)
+      filter = filter_by_name(filter)
+      unless filter.class.included_modules.include?(::Datagrid::Filters::SelectOptions)
+        raise ::Datagrid::ArgumentError,
+          "#{self.class.name}##{filter.name} with type #{FILTER_TYPES.invert[filter.class].inspect} can not have select options"
       end
+      filter
+    end
 
-      def apply_filters(current_scope, filters)
-        filters.inject(current_scope) do |result, filter|
-          filter.apply(self, result, filter_value(filter))
-        end
+    def apply_filters(current_scope, filters)
+      filters.inject(current_scope) do |result, filter|
+        filter.apply(self, result, filter_value(filter))
       end
     end
-
   end
 end

data/lib/datagrid/form_builder.rb

@@ -89,7 +89,7 @@ module Datagrid
     end
 
     def enum_checkbox_checked?(filter, option_value)
-      current_value = object.send(filter.name)
+      current_value = object.public_send(filter.name)
       if current_value.respond_to?(:include?)
         # Typecast everything to string
         # to remove difference between String and Symbol
@@ -166,7 +166,7 @@ module Datagrid
     def datagrid_range_filter_options(object, filter, type, options)
       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]))
+      options[:value] = filter.format(object[filter.name]&.public_send(type_method_map[type]))
       # In case of datagrid ranged filter
       # from and to input will have same id
       if !options.key?(:id)