datagrid 1.8.2 → 2.0.0

data/lib/datagrid/form_builder.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require "action_view"
+require "datagrid/deprecated_object"
 
 module Datagrid
   module FormBuilder
@@ -8,88 +11,112 @@ module Datagrid
     #   * <tt>select</tt> for enum, xboolean filter types
     #   * <tt>check_box</tt> for boolean filter type
     #   * <tt>text_field</tt> for other filter types
-    def datagrid_filter(filter_or_attribute, partials: nil, **options, &block)
+    def datagrid_filter(filter_or_attribute, **options, &block)
       filter = datagrid_get_filter(filter_or_attribute)
-      options = add_html_classes({**filter.input_options, **options}, filter.name, datagrid_filter_html_class(filter))
-      self.send( filter.form_builder_helper_name, filter, **options, &block)
+      if filter.range?
+        datagrid_range_filter(filter, options, &block)
+      elsif filter.enum_checkboxes?
+        datagrid_enum_checkboxes_filter(filter, options, &block)
+      elsif filter.type == :dynamic
+        datagrid_dynamic_filter(filter, options, &block)
+      else
+        datagrid_filter_input(filter, **options, &block)
+      end
     end
 
     # @param filter_or_attribute [Datagrid::Filters::BaseFilter, String, Symbol] filter object or filter name
     # @param text [String, nil] label text, defaults to <tt>filter.header</tt>
     # @param options [Hash] options of rails <tt>label</tt> helper
-    # @return [String] a form label html for the corresponding filter name
+    # @return [String] a form label tag for the corresponding filter name
     def datagrid_label(filter_or_attribute, text = nil, **options, &block)
       filter = datagrid_get_filter(filter_or_attribute)
-      label(filter.name, text || filter.header, **filter.label_options, **options, &block)
-    end
-
-    def datagrid_filter_input(attribute_or_filter, **options)
-      filter = datagrid_get_filter(attribute_or_filter)
-      value = object.filter_value_as_string(filter)
-      if options[:type]&.to_sym == :textarea
-        text_area filter.name, value: value, **options, type: nil
-      else
-        text_field filter.name, value: value, **options
-      end
-    end
-
-    protected
-    def datagrid_extended_boolean_filter(attribute_or_filter, options = {})
-      datagrid_enum_filter(attribute_or_filter, options)
-    end
-
-    def datagrid_boolean_filter(attribute_or_filter, options = {})
-      check_box(datagrid_get_attribute(attribute_or_filter), options)
+      options = { **filter.label_options, **options }
+      label(filter.name, text || filter.header, **options, &block)
     end
 
-    def datagrid_date_filter(attribute_or_filter, options = {})
-      datagrid_range_filter(:date, attribute_or_filter, options)
-    end
-
-    def datagrid_date_time_filter(attribute_or_filter, options = {})
-      datagrid_range_filter(:datetime, attribute_or_filter, options)
-    end
-
-    def datagrid_default_filter(attribute_or_filter, options = {})
-      datagrid_filter_input(attribute_or_filter, **options)
-    end
-
-    def datagrid_enum_filter(attribute_or_filter, options = {}, &block)
+    # @param [Datagrid::Filters::BaseFilter, String, Symbol] attribute_or_filter filter object or filter name
+    # @param options [Hash{Symbol => Object}] HTML attributes to assign to input tag
+    #   * `type` - special attribute the determines an input tag to be made.
+    #     Examples: `text`, `select`, `textarea`, `number`, `date` etc.
+    # @return [String] an input tag for the corresponding filter name
+    def datagrid_filter_input(attribute_or_filter, **options, &block)
       filter = datagrid_get_filter(attribute_or_filter)
-      if filter.checkboxes?
-        options = add_html_classes(options, 'checkboxes')
-        elements = object.select_options(filter).map do |element|
-          text, value = @template.send(:option_text_and_value, element)
-          checked = enum_checkbox_checked?(filter, value)
-          [value, text, checked]
+      options = add_filter_options(filter, **options)
+      type = options.delete(:type)&.to_sym
+      if %i[datetime-local date].include?(type)
+        if options.key?(:value) && options[:value].nil?
+          # https://github.com/rails/rails/pull/53387
+          options[:value] = ""
         end
-        render_partial(
-          'enum_checkboxes',
-          {
-            elements: elements,
-            form: self,
-            filter: filter,
-            options: options,
-          }
-        )
-      else
+      elsif options[:value]
+        options[:value] = filter.format(options[:value])
+      end
+      case type
+      when :"datetime-local"
+        datetime_local_field filter.name, **options, &block
+      when :date
+        date_field filter.name, **options, &block
+      when :textarea
+        text_area filter.name, value: object.filter_value_as_string(filter), **options, &block
+      when :checkbox
+        value = options.fetch(:value, 1).to_s
+        options = { checked: true, **options } if filter.enum_checkboxes? && enum_checkbox_checked?(filter, value)
+        check_box filter.name, options, value
+      when :hidden
+        hidden_field filter.name, **options
+      when :number
+        number_field filter.name, **options
+      when :select
         select(
           filter.name,
           object.select_options(filter) || [],
           {
             include_blank: filter.include_blank,
             prompt: filter.prompt,
-            include_hidden: false
+            include_hidden: false,
           },
-           multiple: filter.multiple?,
-           **options,
-           &block
+          multiple: filter.multiple?,
+          **options,
+          &block
         )
+      else
+        text_field filter.name, value: object.filter_value_as_string(filter), **options, &block
+      end
+    end
+
+    protected
+
+    def datagrid_enum_checkboxes_filter(filter, options = {})
+      elements = object.select_options(filter).map do |element|
+        text, value = @template.send(:option_text_and_value, element)
+        checked = enum_checkbox_checked?(filter, value)
+        [value, text, checked]
       end
+      choices = elements.map do |value, text, *_|
+        [value, text]
+      end
+      render_partial(
+        "enum_checkboxes",
+        {
+          form: self,
+          elements: Datagrid::DeprecatedObject.new(
+            elements,
+          ) do
+            Datagrid::Utils.warn_once(
+              <<~MSG,
+                Using `elements` variable in enum_checkboxes view is deprecated, use `choices` instead.
+              MSG
+            )
+          end,
+          choices: choices,
+          filter: filter,
+          options: options,
+        },
+      )
     end
 
     def enum_checkbox_checked?(filter, option_value)
-      current_value = object.public_send(filter.name)
+      current_value = object.filter_value(filter)
       if current_value.respond_to?(:include?)
         # Typecast everything to string
         # to remove difference between String and Symbol
@@ -99,19 +126,9 @@ module Datagrid
       end
     end
 
-    def datagrid_integer_filter(attribute_or_filter, options = {})
-      filter = datagrid_get_filter(attribute_or_filter)
-      if filter.multiple? && object[filter.name].blank?
-        options[:value] = ""
-      end
-      datagrid_range_filter(:integer, filter, options)
-    end
-
-    def datagrid_dynamic_filter(attribute_or_filter, options = {})
-      filter = datagrid_get_filter(attribute_or_filter)
-      input_name = "#{object_name}[#{filter.name.to_s}][]"
+    def datagrid_dynamic_filter(filter, options = {})
       field, operation, value = object.filter_value(filter)
-      options = options.merge(name: input_name)
+      options = add_filter_options(filter, **options)
       field_input = dynamic_filter_select(
         filter.name,
         object.select_options(filter) || [],
@@ -119,9 +136,10 @@ module Datagrid
           include_blank: filter.include_blank,
           prompt: filter.prompt,
           include_hidden: false,
-          selected: field
+          selected: field,
         },
-        add_html_classes(options, "field")
+        **add_html_classes(options, "datagrid-dynamic-field"),
+        name: @template.field_name(object_name, filter.name, "field"),
       )
       operation_input = dynamic_filter_select(
         filter.name, filter.operations_select,
@@ -131,9 +149,15 @@ module Datagrid
           prompt: false,
           selected: operation,
         },
-        add_html_classes(options, "operation")
+        **add_html_classes(options, "datagrid-dynamic-operation"),
+        name: @template.field_name(object_name, filter.name, "operation"),
+      )
+      value_input = datagrid_filter_input(
+        filter.name,
+        **add_html_classes(options, "datagrid-dynamic-value"),
+        value: value,
+        name: @template.field_name(object_name, filter.name, "value"),
       )
-      value_input = text_field(filter.name, **add_html_classes(options, "value"), value: value)
       [field_input, operation_input, value_input].join("\n").html_safe
     end
 
@@ -149,61 +173,26 @@ module Datagrid
       end
     end
 
-    def datagrid_range_filter(type, attribute_or_filter, options = {})
-      filter = datagrid_get_filter(attribute_or_filter)
-      if filter.range?
-        options = options.merge(multiple: true)
-        from_options = datagrid_range_filter_options(object, filter, :from, options)
-        to_options = datagrid_range_filter_options(object, filter, :to, options)
-        render_partial 'range_filter', {
-          from_options: from_options, to_options: to_options, filter: filter, form: self
-        }
-      else
-        datagrid_filter_input(filter, **options)
-      end
+    def datagrid_range_filter(filter, options = {})
+      from_options = datagrid_range_filter_options(object, filter, :from, **options)
+      to_options = datagrid_range_filter_options(object, filter, :to, **options)
+      render_partial "range_filter", {
+        from_options: from_options, to_options: to_options, filter: filter, form: self,
+      }
     end
 
-    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]&.public_send(type_method_map[type]))
-      # In case of datagrid ranged filter
-      # from and to input will have same id
-      if !options.key?(:id)
-        # Rails provides it's own default id for all inputs
-        # In order to prevent that we assign no id by default
-        options[:id] = nil
-      elsif options[:id].present?
-        # If the id was given we prefix it
-        # with from_ and to_ accordingly
-        options[:id] = [type, options[:id]].join("_")
-      end
+    def datagrid_range_filter_options(object, filter, section, **options)
+      type_method_map = { from: :begin, to: :end }
+      options[:value] = object[filter.name]&.public_send(type_method_map[section])
+      options[:name] = @template.field_name(object_name, filter.name, section)
       options
     end
 
-    def datagrid_string_filter(attribute_or_filter, options = {})
-      datagrid_range_filter(:string, attribute_or_filter, options)
-    end
-
-    def datagrid_float_filter(attribute_or_filter, options = {})
-      datagrid_range_filter(:float, attribute_or_filter, options)
-    end
-
-    def datagrid_get_attribute(attribute_or_filter)
-      Utils.string_like?(attribute_or_filter) ? attribute_or_filter : attribute_or_filter.name
-    end
-
     def datagrid_get_filter(attribute_or_filter)
-      if Utils.string_like?(attribute_or_filter)
-        object.class.filter_by_name(attribute_or_filter) ||
-          raise(Error, "Datagrid filter #{attribute_or_filter} not found")
-      else
-        attribute_or_filter
-      end
-    end
+      return attribute_or_filter unless Utils.string_like?(attribute_or_filter)
 
-    def datagrid_filter_html_class(filter)
-      filter.class.to_s.demodulize.underscore
+      object.class.filter_by_name(attribute_or_filter) ||
+        raise(ArgumentError, "Datagrid filter #{attribute_or_filter} not found")
     end
 
     def add_html_classes(options, *classes)
@@ -211,21 +200,20 @@ module Datagrid
     end
 
     def partial_path(name)
-      if partials = self.options[:partials]
+      if (partials = options[:partials])
         partial_name = File.join(partials, name)
         # Second argument is []: no magical namespaces to lookup added from controller
-        if @template.lookup_context.template_exists?(partial_name, [], true)
-          return partial_name
-        end
+        return partial_name if @template.lookup_context.template_exists?(partial_name, [], true)
       end
-      File.join('datagrid', name)
+      File.join("datagrid", name)
     end
 
     def render_partial(name, locals)
       @template.render partial: partial_path(name), locals: locals
     end
 
-    class Error < StandardError
+    def add_filter_options(filter, **options)
+      { **filter.default_input_options, **filter.input_options, **options }
     end
   end
 end

data/lib/datagrid/generators/scaffold.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Datagrid
+  # @!visibility private
+  module Generators
+    # @!visibility private
+    class Scaffold < Rails::Generators::NamedBase
+      include Rails::Generators::ResourceHelpers
+
+      check_class_collision suffix: "Grid"
+      source_root File.expand_path("#{__FILE__}/../../../templates")
+
+      def create_scaffold
+        template "base.rb.erb", base_grid_file unless file_exists?(base_grid_file)
+        template "grid.rb.erb", "app/grids/#{grid_class_name.underscore}.rb"
+        if file_exists?(grid_controller_file)
+          inject_into_file grid_controller_file, index_action, after: %r{class .*#{grid_controller_class_name}.*\n}
+        else
+          create_file grid_controller_file, controller_code
+        end
+        create_file view_file, view_code
+        route(generate_routing_namespace("resources :#{grid_controller_short_name}"))
+        gem "kaminari" unless kaminari? || will_paginate? || pagy?
+        in_root do
+          {
+            "css" => " *= require datagrid",
+            "css.sass" => " *= require datagrid",
+            "css.scss" => " *= require datagrid",
+          }.each do |extension, string|
+            file = "app/assets/stylesheets/application.#{extension}"
+            if file_exists?(file)
+              inject_into_file file, "#{string}\n", { before: %r{.*require_self} } # before all
+            end
+          end
+        end
+      end
+
+      def view_file
+        Rails.root.join("app/views").join(controller_file_path).join("index.html.erb")
+      end
+
+      def grid_class_name
+        "#{file_name.camelize.pluralize}Grid"
+      end
+
+      def grid_base_class
+        file_exists?("app/grids/base_grid.rb") ? "BaseGrid" : "ApplicationGrid"
+      end
+
+      def grid_controller_class_name
+        "#{controller_class_name.camelize}Controller"
+      end
+
+      def grid_controller_file
+        Rails.root.join("app/controllers").join("#{grid_controller_class_name.underscore}.rb")
+      end
+
+      def grid_controller_short_name
+        controller_file_name
+      end
+
+      def grid_model_name
+        file_name.camelize.singularize
+      end
+
+      def grid_param_name
+        grid_class_name.underscore
+      end
+
+      def pagination_helper_code
+        if will_paginate?
+          "will_paginate(@grid.assets)"
+        elsif pagy?
+          "pagy_nav(@pagy)"
+        else
+          # Kaminari is default
+          "paginate(@grid.assets)"
+        end
+      end
+
+      def table_helper_code
+        if pagy?
+          "datagrid_table @grid, @records"
+        else
+          "datagrid_table @grid"
+        end
+      end
+
+      def base_grid_file
+        "app/grids/application_grid.rb"
+      end
+
+      def grid_route_name
+        "#{controller_class_name.underscore.gsub('/', '_')}_path"
+      end
+
+      def index_code
+        if pagy?
+          <<-RUBY
+    @grid = #{grid_class_name}.new(grid_params)
+    @pagy, @assets = pagy(@grid.assets)
+          RUBY
+        else
+          <<-RUBY
+    @grid = #{grid_class_name}.new(grid_params) do |scope|
+      scope.page(params[:page])
+    end
+          RUBY
+        end
+      end
+
+      def controller_code
+        <<~RUBY
+          class #{grid_controller_class_name} < ApplicationController
+            def index
+          #{index_code.rstrip}
+            end
+
+            protected
+
+            def grid_params
+              params.fetch(:#{grid_param_name}, {}).permit!
+            end
+          end
+        RUBY
+      end
+
+      def view_code
+        <<~ERB
+          <%= datagrid_form_with model: @grid, url: #{grid_route_name} %>
+
+          <%= #{pagination_helper_code} %>
+          <%= #{table_helper_code} %>
+          <%= #{pagination_helper_code} %>
+        ERB
+      end
+
+      protected
+
+      def generate_routing_namespace(code)
+        depth = regular_class_path.length
+        # Create 'namespace' ladder
+        # namespace :foo do
+        #   namespace :bar do
+        namespace_ladder = regular_class_path.each_with_index.map do |ns, i|
+          indent("namespace :#{ns} do\n", i * 2)
+        end.join
+
+        # Create route
+        #     get 'baz/index'
+        route = indent(code, depth * 2)
+
+        # Create `end` ladder
+        #   end
+        # end
+        end_ladder = (1..depth).reverse_each.map do |i|
+          indent("end\n", i * 2)
+        end.join
+
+        # Combine the 3 parts to generate complete route entry
+        "#{namespace_ladder}#{route}\n#{end_ladder}"
+      end
+
+      def file_exists?(name)
+        name = Rails.root.join(name) unless name.to_s.first == "/"
+        File.exist?(name)
+      end
+
+      def pagy?
+        defined?(::Pagy)
+      end
+
+      def will_paginate?
+        defined?(::WillPaginate)
+      end
+
+      def kaminari?
+        defined?(::Kaminari)
+      end
+    end
+  end
+end

data/lib/datagrid/generators/views.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datagrid
+  module Generators
+    class Views < Rails::Generators::Base
+      source_root File.expand_path("../../../app/views/datagrid", __dir__)
+
+      desc "Copies Datagrid partials to your application."
+      def copy_views
+        Dir.glob(File.join(self.class.source_root, "**", "*")).each do |file_path|
+          relative_path = file_path.sub("#{self.class.source_root}/", "")
+
+          next if relative_path == "_order_for.html.erb"
+
+          copy_file(relative_path, File.join("app/views/datagrid", relative_path))
+        end
+      end
+    end
+  end
+end