datagrid 1.8.1 → 2.0.0.pre.alpha

data/lib/datagrid/column_names_attribute.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Datagrid
   module ColumnNamesAttribute
     extend ActiveSupport::Concern
@@ -21,6 +23,7 @@ module Datagrid
       # will always present in the grid table and won't be listed
       # in column names selection
       # Accepts same options as <tt>:enum</tt> filter
+      # @return [Datagrid::Filters::BaseFilter] Defined filter object
       # @example
       #   column_names_filter(header: "Choose columns")
       # @see Datagrid::Filters::ClassMethods#filter
@@ -44,7 +47,7 @@ module Datagrid
     # If no mandatory columns specified than all of them considered mandatory
     # @return [Array<Datagrid::Columns::Column>]
     def mandatory_columns
-      available_columns.select {|c| c.mandatory? }
+      available_columns.select(&:mandatory?)
     end
 
     # Returns a list of enabled columns without <tt>mandatory: true</tt> option
@@ -57,27 +60,25 @@ module Datagrid
     protected
 
     def optional_columns_select
-      optional_columns.map {|c| [c.header, c.name] }
+      optional_columns.map { |c| [c.header, c.name] }
     end
 
     def selected_column_names(*args)
       if args.any?
         args.compact!
-        args.map!(&:to_sym)
+        args.map! do |column|
+          column.is_a?(Datagrid::Columns::Column) ? column.name : column.to_sym
+        end
         args
+      elsif column_names&.any?
+        column_names + mandatory_columns.map(&:name)
       else
-        if column_names && column_names.any?
-          column_names + mandatory_columns.map(&:name)
-        else
-          columns_enabled_by_default.map(&:name)
-        end
+        columns_enabled_by_default.map(&:name)
       end
     end
 
     def columns_visibility_enabled?
-      columns_array.any? do |column|
-        column.mandatory_explicitly_set?
-      end
+      columns_array.any?(&:mandatory_explicitly_set?)
     end
 
     def columns_enabled_by_default
@@ -85,4 +86,3 @@ module Datagrid
     end
   end
 end
-

data/lib/datagrid/columns/column.rb

@@ -1,164 +1,186 @@
-class Datagrid::Columns::Column
-
-  # Datagrid class holding an information of
-  # how a column should be rendered in data/console/csv format and HTML format
-  class ResponseFormat
-
-    attr_accessor :data_block, :html_block
-
-    def initialize
-      yield(self)
-    end
-
-    def data(&block)
-      self.data_block = block
-    end
-
-    def html(&block)
-      self.html_block = block
-    end
-
-    def call_data
-      data_block.call
-    end
+# frozen_string_literal: true
+
+module Datagrid
+  module Columns
+    class Column
+      # Datagrid class holding an information of
+      # how a column should be rendered in data/console/csv format and HTML format
+      class ResponseFormat
+        attr_accessor :data_block, :html_block
+
+        def initialize
+          yield(self)
+        end
+
+        def data(&block)
+          self.data_block = block
+        end
+
+        def html(&block)
+          self.html_block = block
+        end
+
+        def call_data
+          data_block.call
+        end
+
+        def to_s
+          call_data.to_s
+        end
+
+        def call_html(context)
+          context.instance_eval(&html_block)
+        end
+      end
 
-    def to_s
-      call_data.to_s
-    end
+      attr_accessor :grid_class, :options, :data_block, :name, :html_block, :query
+
+      def initialize(grid_class, name, query, options = {}, &block)
+        self.grid_class = grid_class
+        self.name = name.to_sym
+        self.options = options
+        if options[:class]
+          Datagrid::Utils.warn_once(
+            "column[class] option is deprecated. Use {tag_options: {class: ...}} instead.",
+          )
+          self.options[:tag_options] = {
+            **self.options.fetch(:tag_options, {}),
+            class: options[:class],
+          }
+        end
+        if options[:html] == true
+          self.html_block = block
+        else
+          self.data_block = block
+
+          self.html_block = options[:html] if options[:html].is_a? Proc
+        end
+        self.query = query
+      end
 
-    def call_html(context)
-      context.instance_eval(&html_block)
-    end
-  end
+      def data_value(model, grid)
+        # backward compatibility method
+        grid.data_value(name, model)
+      end
 
-  attr_accessor :grid_class, :options, :data_block, :name, :html_block, :query
+      def label
+        options[:label]
+      end
 
-  def initialize(grid_class, name, query, options = {}, &block)
-    self.grid_class = grid_class
-    self.name = name.to_sym
-    self.options = options
-    if options[:html] == true
-      self.html_block = block
-    else
-      self.data_block = block
+      def header
+        if (header = options[:header])
+          Datagrid::Utils.callable(header)
+        else
+          Datagrid::Utils.translate_from_namespace(:columns, grid_class, name)
+        end
+      end
 
-      if options[:html].is_a? Proc
-        self.html_block = options[:html]
+      def order
+        if options.key?(:order) && options[:order] != true
+          options[:order]
+        else
+          driver.default_order(grid_class.scope, name)
+        end
       end
-    end
-    self.query = query
-  end
 
-  def data_value(model, grid)
-    # backward compatibility method
-    grid.data_value(name, model)
-  end
+      def supports_order?
+        order || order_by_value?
+      end
 
+      def order_by_value(model, grid)
+        if options[:order_by_value] == true
+          grid.data_value(self, model)
+        else
+          Datagrid::Utils.apply_args(model, grid, &options[:order_by_value])
+        end
+      end
 
-  def label
-    self.options[:label]
-  end
+      def order_by_value?
+        !!options[:order_by_value]
+      end
 
-  def header
-    if header = options[:header]
-      Datagrid::Utils.callable(header)
-    else
-      Datagrid::Utils.translate_from_namespace(:columns, grid_class, name)
-    end
-  end
+      def order_desc
+        return nil unless order
 
-  def order
-    if options.has_key?(:order) && options[:order] != true
-      self.options[:order]
-    else
-      driver.default_order(grid_class.scope, name)
-    end
-  end
+        options[:order_desc]
+      end
 
-  def supports_order?
-    order || order_by_value?
-  end
+      def html?
+        options[:html] != false
+      end
 
-  def order_by_value(model, grid)
-    if options[:order_by_value] == true
-      grid.data_value(self, model)
-    else
-      Datagrid::Utils.apply_args(model, grid, &options[:order_by_value])
-    end
-  end
+      def data?
+        data_block != nil
+      end
 
-  def order_by_value?
-    !! options[:order_by_value]
-  end
+      def mandatory?
+        !!options[:mandatory]
+      end
 
-  def order_desc
-    return nil unless order
-    self.options[:order_desc]
-  end
+      def tag_options
+        options[:tag_options] || {}
+      end
 
-  def html?
-    options[:html] != false
-  end
+      def html_class
+        Datagrid::Utils.warn_once(
+          "Column#html_class is deprecated. Use Column#tag_options instead.",
+        )
+        options[:class]
+      end
 
-  def data?
-    self.data_block != nil
-  end
+      def mandatory_explicitly_set?
+        options.key?(:mandatory)
+      end
 
-  def mandatory?
-    !! options[:mandatory]
-  end
+      def enabled?(grid)
+        ::Datagrid::Utils.process_availability(grid, options[:if], options[:unless])
+      end
 
-  def mandatory_explicitly_set?
-    options.key?(:mandatory)
-  end
+      def inspect
+        "#<#{self.class} #{grid_class}##{name} #{options.inspect}>"
+      end
 
-  def enabled?(grid)
-    ::Datagrid::Utils.process_availability(grid, options[:if], options[:unless])
-  end
+      def to_s
+        header
+      end
 
-  def inspect
-    "#<#{self.class} #{grid_class}##{name} #{options.inspect}>"
-  end
+      def html_value(context, asset, grid)
+        grid.html_value(name, context, asset)
+      end
 
-  def to_s
-    header
-  end
+      def generic_value(model, grid)
+        grid.generic_value(self, model)
+      end
 
-  def html_value(context, asset, grid)
-    grid.html_value(name, context, asset)
-  end
+      def append_preload(relation)
+        return relation unless preload
 
+        if preload.respond_to?(:call)
+          return relation unless preload
 
-  def generic_value(model, grid)
-    grid.generic_value(self, model)
-  end
+          if preload.arity == 1
+            preload.call(relation)
+          else
+            relation.instance_exec(&preload)
+          end
+        else
+          driver.default_preload(relation, preload)
+        end
+      end
 
-  def append_preload(relation)
-    return relation unless preload
-    if preload.respond_to?(:call)
-      return relation unless preload
-      if preload.arity == 1
-        preload.call(relation)
-      else
-        relation.instance_exec(&preload)
-      end
-    else
-      driver.default_preload(relation, preload)
-    end
-  end
+      def preload
+        preload = options[:preload]
 
-  def preload
-    preload = options[:preload]
+        if preload == true && driver.can_preload?(grid_class.scope, name)
+          name
+        else
+          preload
+        end
+      end
 
-    if preload == true && driver.can_preload?(grid_class.scope, name)
-      name
-    else
-      preload
+      def driver
+        grid_class.driver
+      end
     end
-
-  end
-
-  def driver
-    grid_class.driver
   end
 end