datagrid 1.8.1 → 2.0.0.pre.alpha

data/lib/datagrid/ordering.rb

@@ -1,132 +1,126 @@
+# frozen_string_literal: true
+
 require "datagrid/columns"
 
 module Datagrid
   # Raised when grid order value is incorrect
   class OrderUnsupported < StandardError
   end
-  module Ordering
 
+  # Module adds support for ordering by defined columns for Datagrid.
+  module Ordering
     # @!visibility private
     def self.included(base)
-      base.extend         ClassMethods
+      base.extend ClassMethods
       base.class_eval do
         include Datagrid::Columns
 
         datagrid_attribute :order do |value|
-          if value.present?
-            value.to_sym
-          else
-            nil
-          end
-
+          value.to_sym if value.present?
         end
 
         datagrid_attribute :descending do |value|
           Datagrid::Utils.booleanize(value)
         end
-        alias descending? descending
-
+        alias_method :descending?, :descending
       end
-      base.include InstanceMethods
     end
 
     # @!visibility private
     module ClassMethods
       def order_unsupported(name, reason)
-        raise Datagrid::OrderUnsupported, "Can not sort #{self.inspect} by ##{name}: #{reason}"
+        raise Datagrid::OrderUnsupported, "Can not sort #{inspect} by ##{name}: #{reason}"
       end
     end
 
-    module InstanceMethods
+    # @!visibility private
+    def assets
+      check_order_valid!
+      apply_order(super)
+    end
 
-      # @!visibility private
-      def assets
-        check_order_valid!
-        apply_order(super)
-      end
+    # @return [Datagrid::Columns::Column, nil] a column definition that is currently used to order assets
+    # @example
+    #   class MyGrid
+    #     scope { Model }
+    #     column(:id)
+    #     column(:name)
+    #   end
+    #   MyGrid.new(order: "name").order_column # => #<Column name: "name", ...>
+    def order_column
+      order ? column_by_name(order) : nil
+    end
 
-      # @return [Datagrid::Columns::Column, nil] a column definition that is currently used to order assets
-      # @example
-      #   class MyGrid
-      #     scope { Model }
-      #     column(:id)
-      #     column(:name)
-      #   end
-      #   MyGrid.new(order: "name").order_column # => #<Column name: "name", ...>
-      def order_column
-        order ? column_by_name(order) : nil
-      end
+    # @param column [String, Datagrid::Columns::Column]
+    # @param desc [nil, Boolean] confirm order direction as well if specified
+    # @return [Boolean] true if given grid is ordered by given column.
+    def ordered_by?(column, desc = nil)
+      order_column == column_by_name(column) &&
+        (desc.nil? || (desc ? descending? : !descending?))
+    end
 
-      # @param column [String, Datagrid::Columns::Column]
-      # @return [Boolean] true if given grid is ordered by given column.
-      def ordered_by?(column)
-        order_column == column_by_name(column)
-      end
+    private
 
-      private
+    def apply_order(assets)
+      return assets unless order
 
-      def apply_order(assets)
-        return assets unless order
-        if order_column.order_by_value?
-          assets = assets.sort_by do |asset|
-            order_column.order_by_value(asset, self)
-          end
-          descending? ? assets.reverse : assets
+      if order_column.order_by_value?
+        assets = assets.sort_by do |asset|
+          order_column.order_by_value(asset, self)
+        end
+        descending? ? assets.reverse : assets
+      elsif descending?
+        if order_column.order_desc
+          apply_asc_order(assets, order_column.order_desc)
         else
-          if descending?
-            if order_column.order_desc
-              apply_asc_order(assets, order_column.order_desc)
-            else
-              apply_desc_order(assets, order_column.order)
-            end
-          else
-            apply_asc_order(assets, order_column.order)
-          end
+          apply_desc_order(assets, order_column.order)
         end
+      else
+        apply_asc_order(assets, order_column.order)
       end
+    end
 
-      def check_order_valid!
-        return unless order
-        column = column_by_name(order)
-        unless column
-          self.class.order_unsupported(order, "no column #{order} in #{self.class}")
-        end
-        unless column.supports_order?
-          self.class.order_unsupported(column.name, "column don't support order" )
-        end
-      end
+    def check_order_valid!
+      return unless order
 
-      def apply_asc_order(assets, order)
-        if order.respond_to?(:call)
-          apply_block_order(assets, order)
-        else
-          driver.asc(assets, order)
-        end
-      end
+      column = column_by_name(order)
+      self.class.order_unsupported(order, "no column #{order} in #{self.class}") unless column
+      return if column.supports_order?
 
-      def apply_desc_order(assets, order)
-        if order.respond_to?(:call)
-          reverse_order(apply_asc_order(assets, order))
-        else
-          driver.desc(assets, order)
-        end
+      self.class.order_unsupported(column.name, "column don't support order")
+    end
+
+    def apply_asc_order(assets, order)
+      if order.respond_to?(:call)
+        apply_block_order(assets, order)
+      else
+        driver.asc(assets, order)
       end
+    end
 
-      def reverse_order(assets)
-        driver.reverse_order(assets)
-      rescue NotImplementedError
-        self.class.order_unsupported(order_column.name, "Your ORM do not support reverse order: please specify :order_desc option manually")
+    def apply_desc_order(assets, order)
+      if order.respond_to?(:call)
+        reverse_order(apply_asc_order(assets, order))
+      else
+        driver.desc(assets, order)
       end
+    end
 
-      def apply_block_order(assets, order)
-        case order.arity
-        when -1, 0
-          assets.instance_eval(&order)
-        when 1
-          order.call(assets)
-        else
-          self.class.order_unsupported(order_column.name, "Order option proc can not handle more than one argument")
-        end
+    def reverse_order(assets)
+      driver.reverse_order(assets)
+    rescue NotImplementedError
+      self.class.order_unsupported(order_column.name,
+        "Your ORM do not support reverse order: please specify :order_desc option manually",)
+    end
+
+    def apply_block_order(assets, order)
+      case order.arity
+      when -1, 0
+        assets.instance_eval(&order)
+      when 1
+        order.call(assets)
+      else
+        self.class.order_unsupported(order_column.name, "Order option proc can not handle more than one argument")
       end
     end
   end

data/lib/datagrid/rspec.rb

@@ -1,16 +1,16 @@
+# frozen_string_literal: true
+
 require "datagrid"
 
-#TODO: refactor this experimental shit
+# TODO: refactor this experimental shit
 shared_examples_for "Datagrid" do
   describe "as Datagrid" do
-
     it "should have at least one entry if assets" do
       subject.assets.should_not be_empty
     end
 
-    described_class.columns(:data => true).each do |column|
+    described_class.columns(data: true).each do |column|
       describe "column ##{column.name}" do
-
         it "should has value in #data_hash" do
           subject.data_hash.first.should have_key(column.name)
         end
@@ -25,14 +25,11 @@ shared_examples_for "Datagrid" do
           subject.assets.first.should_not be_nil
         end
       end
-
     end
 
     described_class.filters.each do |filter|
       describe "filter ##{filter.name}" do
-
         let(:filter_value) do
-
           case Datagrid::Filters::FILTER_TYPES.invert[filter.class]
           when :default, :string
             "text"
@@ -46,23 +43,22 @@ shared_examples_for "Datagrid" do
             1
           when :enum
             select = subject.select_options(filter)
-            select.first.try(:last)
+            select.first&.last
           else
             raise "unknown filter type: #{filter.class}"
           end.to_s
         end
 
         before(:each) do
-          subject.attributes = {filter.name => filter_value}
-          subject.send(filter.name).should_not be_nil
+          subject.attributes = { filter.name => filter_value }
+          subject.public_send(filter.name).should_not be_nil
         end
 
         it "should be supported" do
           subject.assets.should_not be_nil
-          #TODO: better matcher.
+          # TODO: better matcher.
         end
       end
     end
-
   end
 end

data/lib/datagrid/utils.rb

@@ -1,52 +1,54 @@
+# frozen_string_literal: true
+
 module Datagrid
   # @!visibility private
-  module Utils # :nodoc:
+  module Utils
     class << self
-
-
-      TRUTH = [true, 1, "1", "true", "yes", "on"]
+      TRUTH = [true, 1, "1", "true", "yes", "on"].freeze
 
       def booleanize(value)
-        if value.respond_to?(:downcase)
-          value = value.downcase
-        end
+        value = value.downcase if value.respond_to?(:downcase)
         TRUTH.include?(value)
       end
 
       def translate_from_namespace(namespace, grid_class, key)
-
         lookups = []
         namespaced_key = "#{namespace}.#{key}"
 
         grid_class.ancestors.each do |ancestor|
-          if ancestor.respond_to?(:model_name)
-            lookups << :"datagrid.#{ancestor.model_name.i18n_key}.#{namespaced_key}"
-          end
+          lookups << :"datagrid.#{ancestor.model_name.i18n_key}.#{namespaced_key}" if ancestor.respond_to?(:model_name)
         end
         lookups << :"datagrid.defaults.#{namespaced_key}"
         lookups << key.to_s.humanize
         I18n.t(lookups.shift, default: lookups).presence
       end
 
+      def deprecator
+        if defined?(Rails) && Rails.version >= "7.1.0"
+          Rails.deprecator
+        else
+          ActiveSupport::Deprecation
+        end
+      end
+
       def warn_once(message, delay = 5)
         @warnings ||= {}
         timestamp = @warnings[message]
         return false if timestamp && timestamp >= Time.now - delay
-        warn message
+
+        deprecator.warn(message)
         @warnings[message] = Time.now
         true
       end
 
       def add_html_classes(options, *classes)
+        return options if classes.empty?
+
         options = options.clone
-        options[:class] ||= ""
-        if options[:class].is_a?(Array)
-          options[:class] += classes
-        else
-          # suppose that it is a String
-          options[:class] += " " unless options[:class].blank?
-          options[:class] += classes.join(" ")
-        end
+        options[:class] ||= []
+        array = options[:class].is_a?(Array)
+        value = [*options[:class], *classes]
+        options[:class] = array ? value : value.join(" ")
         options
       end
 
@@ -55,41 +57,42 @@ module Datagrid
       end
 
       def extract_position_from_options(array, options)
-        before, after = options[:before], options[:after]
-        if before && after
-          raise Datagrid::ConfigurationError, "Options :before and :after can not be used together"
-        end
+        before = options[:before]
+        after = options[:after]
+        raise Datagrid::ConfigurationError, "Options :before and :after can not be used together" if before && after
         # Consider as before all
         return 0 if before == true
+
         if before
           before = before.to_sym
-          array.index {|c| c.name.to_sym == before }
+          array.index { |c| c.name.to_sym == before }
         elsif after
           after = after.to_sym
-          array.index {|c| c.name.to_sym == after } + 1
+          array.index { |c| c.name.to_sym == after } + 1
         else
           -1
         end
       end
 
       def apply_args(*args, &block)
-        size = block.arity < 0 ? args.size : block.arity
+        size = block.arity.negative? ? args.size : block.arity
         block.call(*args.slice(0, size))
       end
 
       def parse_date(value)
         return nil if value.blank?
         return value if value.is_a?(Range)
+
         if value.is_a?(String)
           Array(Datagrid.configuration.date_formats).each do |format|
-            begin
-              return Date.strptime(value, format)
-            rescue ::ArgumentError
-            end
+            return Date.strptime(value, format)
+          rescue ::ArgumentError
+            nil
           end
         end
         return Date.parse(value) if value.is_a?(String)
         return value.to_date if value.respond_to?(:to_date)
+
         value
       rescue ::ArgumentError
         nil
@@ -98,16 +101,18 @@ module Datagrid
       def parse_datetime(value)
         return nil if value.blank?
         return value if value.is_a?(Range)
+        return value if defined?(ActiveSupport::TimeWithZone) && value.is_a?(ActiveSupport::TimeWithZone)
+
         if value.is_a?(String)
           Array(Datagrid.configuration.datetime_formats).each do |format|
-            begin
-              return Time.strptime(value, format)
-            rescue ::ArgumentError
-            end
+            return Time.strptime(value, format)
+          rescue ::ArgumentError
+            nil
           end
         end
         return Time.parse(value) if value.is_a?(String)
         return value.to_time if value.respond_to?(:to_time)
+
         value
       rescue ::ArgumentError
         nil
@@ -116,10 +121,8 @@ module Datagrid
       def format_date_as_timestamp(value)
         if !value
           value
-        elsif value.is_a?(Array)
-          [value.first.try(:beginning_of_day), value.last.try(:end_of_day)]
         elsif value.is_a?(Range)
-          (value.first.beginning_of_day..value.last.end_of_day)
+          value.begin&.beginning_of_day..value.end&.end_of_day
         else
           value.beginning_of_day..value.end_of_day
         end
@@ -135,6 +138,7 @@ module Datagrid
       end
 
       protected
+
       def property_availability(grid, option, default)
         case option
         when nil

data/lib/datagrid/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datagrid
-  VERSION = "1.8.1"
+  VERSION = "2.0.0-alpha"
 end

data/lib/datagrid.rb

@@ -1,49 +1,39 @@
+# frozen_string_literal: true
+
 require "action_view"
 require "datagrid/configuration"
+require "datagrid/engine"
 
+# @main README.md
 module Datagrid
-
-  extend ActiveSupport::Autoload
-
-  autoload :Core
-  autoload :ActiveModel
-  autoload :Filters
-  autoload :Columns
-  autoload :ColumnNamesAttribute
-  autoload :Ordering
-  autoload :Configuration
-
-  autoload :Helper
-  ActionView::Base.send(:include, Datagrid::Helper)
-
-  autoload :FormBuilder
-  ActionView::Helpers::FormBuilder.send(:include, Datagrid::FormBuilder)
-
-  autoload :Renderer
-
-  autoload :Engine
-
   # @!visibility private
   def self.included(base)
+    Utils.warn_once("Including Datagrid is deprecated. Inherit Datagrid::Base instead.")
     base.class_eval do
-
       include ::Datagrid::Core
       include ::Datagrid::ActiveModel
       include ::Datagrid::Filters
       include ::Datagrid::Columns
       include ::Datagrid::ColumnNamesAttribute
       include ::Datagrid::Ordering
-
     end
   end
 
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Configure
+  def self.configure(&block)
+    block.call(configuration)
+  end
+
   class ConfigurationError < StandardError; end
   class ArgumentError < ::ArgumentError; end
   class ColumnUnavailableError < StandardError; end
-
 end
 
-require "datagrid/scaffold"
-I18n.load_path << File.expand_path('../datagrid/locale/en.yml', __FILE__)
-
-
+require "datagrid/base"
+require "datagrid/generators/scaffold"
+require "datagrid/generators/views"
+I18n.load_path << File.expand_path("datagrid/locale/en.yml", __dir__)

data/templates/base.rb.erb

@@ -1,7 +1,4 @@
-class BaseGrid
-
-  include Datagrid
-
+class ApplicationGrid < Datagrid::Base
   self.default_column_options = {
     # Uncomment to disable the default order
     # order: false,
@@ -11,11 +8,40 @@ class BaseGrid
   # Enable forbidden attributes protection
   # self.forbidden_attributes_protection = true
 
-  def self.date_column(name, *args)
+  # Makes a date column
+  # @param name [Symbol] Column name
+  # @param args [Array] Other column helper arguments
+  # @example
+  #   date_column(:created_at)
+  #   date_column(:owner_registered_at) do |model|
+  #     model.owner.registered_at
+  #   end
+  def self.date_column(name, *args, &block)
     column(name, *args) do |model|
-      format(block_given? ? yield : model.send(name)) do |date|
-        date.strftime("%m/%d/%Y")
+      format(block ? block.call(model) : model.public_send(name)) do |date|
+        date&.strftime("%m/%d/%Y") || "&mdash;".html_safe
       end
     end
   end
+
+  # Makes a boolean YES/NO column
+  # @param name [Symbol] Column name
+  # @param args [Array] Other column helper arguments
+  # @example
+  #   boolean_column(:approved)
+  #   boolean_column(:has_tasks, preload: :tasks) do |model|
+  #     model.tasks.unfinished.any?
+  #   end
+  def self.boolean_column(name, *args, &block)
+    column(name, *args) do |model|
+      value = block ? block.call(model) : model.public_send(name)
+      value ? "Yes" : "No"
+    end
+  end
+
+  # Uncomment to shorten URL query string for all grids.
+  # May cause collisions if multiple grids are used on the same page.
+  # def param_name
+  #   'grid'
+  # end
 end

data/templates/grid.rb.erb

@@ -1,4 +1,4 @@
-class <%= grid_class_name %> < BaseGrid
+class <%= grid_class_name %> < <%= grid_base_class %>
 
   scope do
     <%= grid_model_name %>