active_scaffold 3.6.0.pre → 3.6.0.rc1

data/lib/active_scaffold/helpers/association_helpers.rb

@@ -16,11 +16,8 @@ module ActiveScaffold
       def association_options_find(association, conditions = nil, klass = nil, record = nil)
         if klass.nil? && association.polymorphic?
           class_name = record.send(association.foreign_type) if association.belongs_to?
-          if class_name.present?
-            klass = class_name.constantize
-          else
-            return []
-          end
+          return [] if class_name.blank?
+          klass = class_name.constantize
           cache = !block_given?
         else
           cache = !block_given? && klass.nil?
@@ -37,7 +34,9 @@ module ActiveScaffold
             relation = relation.includes(include_assoc[association.name]) if include_assoc
           end
           if column&.sort && column.sort&.dig(:sql)
-            relation = relation.order(column.sort[:sql])
+            # with threasafe enabled, column.sort[:sql] returns proxied strings and
+            # regexp capture won't work, which rails uses internally, so to_s is needed
+            relation = relation.order(Array(column.sort[:sql]).map(&:to_s))
           end
           relation = yield(relation) if block_given?
           relation.to_a
@@ -45,7 +44,11 @@ module ActiveScaffold
       end
 
       def column_for_association(association, record)
-        active_scaffold_config_for(record.class).columns[association.name] rescue nil
+        active_scaffold_config_for(record.class).columns[association.name]
+      rescue StandardError => e
+        message = "Error on config for #{record.class.name}:"
+        Rails.logger.warn "#{message}\n#{e.message}\n#{e.backtrace.join("\n")}"
+        nil
       end
 
       def association_klass_scoped(association, klass, record)
@@ -86,10 +89,9 @@ module ActiveScaffold
       # Check association.name to specialize the conditions per-column.
       def options_for_association_conditions(association, record = nil)
         return nil if association.through?
-        if association.has_one? || association.has_many?
-          # Find only orphaned objects
-          {association.foreign_key => nil}
-        end
+        return nil unless association.has_one? || association.has_many?
+        # Find only orphaned objects
+        {association.foreign_key => nil}
       end
 
       def record_select_params_for_add_existing(association, edit_associated_url_options, record)

data/lib/active_scaffold/helpers/controller_helpers.rb

@@ -2,15 +2,14 @@ module ActiveScaffold
   module Helpers
     module ControllerHelpers
       def self.included(controller)
-        if controller.respond_to? :helper_method
-          controller.class_eval do
-            helper_method :params_for, :conditions_from_params, :render_parent?,
-                          :main_path_to_return, :render_parent_options,
-                          :render_parent_action, :nested_singular_association?,
-                          :main_form_controller, :build_associated,
-                          :generate_temporary_id, :generated_id,
-                          :active_scaffold_config_for
-          end
+        return unless controller.respond_to? :helper_method
+        controller.class_eval do
+          helper_method :params_for, :conditions_from_params, :render_parent?,
+                        :main_path_to_return, :render_parent_options,
+                        :render_parent_action, :nested_singular_association?,
+                        :main_form_controller, :build_associated,
+                        :generate_temporary_id, :generated_id,
+                        :active_scaffold_config_for
         end
       end
 
@@ -27,10 +26,14 @@ module ActiveScaffold
 
       def generate_temporary_id(record = nil, generated_id = nil)
         (generated_id || (Time.now.to_f * 1000).to_i.to_s).tap do |id|
-          (@temporary_ids ||= {})[record.class.name] = id if record
+          cache_generated_id record, id
         end
       end
 
+      def cache_generated_id(record, generated_id)
+        (@temporary_ids ||= {})[record.class.name] = generated_id if record && generated_id
+      end
+
       def generated_id(record)
         @temporary_ids[record.class.name] if record && @temporary_ids
       end
@@ -101,7 +104,7 @@ module ActiveScaffold
         else
           exclude_parameters = %i[utf8 associated_id]
           parameters = {}
-          if params[:parent_scaffold] && nested? && nested.singular_association?
+          if params[:parent_scaffold] && nested_singular_association?
             parameters[:controller] = params[:parent_scaffold]
             exclude_parameters.concat [nested.param_name, :association, :parent_scaffold]
             # parameters[:eid] = params[:parent_scaffold] # not neeeded anymore?

data/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -16,47 +16,43 @@ module ActiveScaffold
         # first, check if the dev has created an override for this specific field
         if (method = override_form_field(column))
           send(method, record, options)
+
         # second, check if the dev has specified a valid form_ui for this column
         elsif column.form_ui && (method = override_input(column.form_ui))
           send(method, column, options)
-        # fallback: we get to make the decision
-        else
-          if column.association
-            if column.form_ui.nil?
-              # its an association and nothing is specified, we will assume form_ui :select
-              active_scaffold_input_select(column, options)
-            else
-              # if we get here, it's because the column has a form_ui but not one ActiveScaffold knows about.
-              raise "Unknown form_ui `#{column.form_ui}' for column `#{column.name}'"
-            end
-          elsif column.virtual?
-            options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
-            active_scaffold_input_virtual(column, options)
-
-          else # regular model attribute column
-            # if we (or someone else) have created a custom render option for the column type, use that
-            if (method = override_input(column.column.type))
-              send(method, column, options)
-            # final ultimate fallback: use rails' generic input method
-            else
-              # for textual fields we pass different options
-              text_types = %i[text string integer float decimal]
-              options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
-              if column.column.type == :string && options[:maxlength].blank?
-                options[:maxlength] = column.column.limit
-                options[:size] ||= options[:maxlength].to_i > 30 ? 30 : options[:maxlength]
-              end
-              options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
-              text_field(:record, column.name, options.merge(column.options).except(:format))
-            end
+
+        elsif column.association
+          # if we get here, it's because the column has a form_ui but not one ActiveScaffold knows about.
+          raise "Unknown form_ui `#{column.form_ui}' for column `#{column.name}'" if column.form_ui
+
+          # its an association and nothing is specified, we will assume form_ui :select
+          active_scaffold_input_select(column, options)
+
+        elsif column.virtual?
+          options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
+          active_scaffold_input_virtual(column, options)
+
+        elsif (method = override_input(column.column.type)) # regular model attribute column
+          # if we (or someone else) have created a custom render option for the column type, use that
+          send(method, column, options)
+
+        else # final ultimate fallback: use rails' generic input method
+          # for textual fields we pass different options
+          text_types = %i[text string integer float decimal]
+          options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
+          if column.column.type == :string && options[:maxlength].blank?
+            options[:maxlength] = column.column.limit
+            options[:size] ||= options[:maxlength].to_i > 30 ? 30 : options[:maxlength]
           end
+          options[:value] = format_number_value(record.send(column.name), column.options) if column.number?
+          text_field(:record, column.name, options.merge(column.options).except(:format))
         end
       rescue StandardError => e
         logger.error "#{e.class.name}: #{e.message} -- on the ActiveScaffold column = :#{column.name} in #{controller.class}"
         raise e
       end
 
-      def active_scaffold_render_subform_column(column, scope, crud_type, readonly, add_class = false, record = nil)
+      def active_scaffold_render_subform_column(column, scope, crud_type, readonly, add_class = false, record = nil) # rubocop:disable Metrics/ParameterLists
         if add_class
           col_class = []
           col_class << 'required' if column.required?
@@ -134,7 +130,7 @@ module ActiveScaffold
             url_params = url_params.except(:parent_scaffold, :association, nested.param_name)
           end
           if scope
-            url_params[:parent_controller] ||= url_params[:controller].gsub(%r{/^//}, '')
+            url_params[:parent_controller] ||= url_params[:controller].gsub(%r{^/}, '')
             url_params[:controller] = subform_controller.controller_path
             url_params[:scope] = scope
             url_params[:parent_id] = params[:parent_id] || params[:id]
@@ -152,8 +148,8 @@ module ActiveScaffold
         {}
       end
 
-      def render_column(column, record, renders_as, scope = nil, only_value = false, col_class = nil)
-        if partial = override_form_field_partial(column)
+      def render_column(column, record, renders_as, scope = nil, only_value = false, col_class = nil) # rubocop:disable Metrics/ParameterLists
+        if (partial = override_form_field_partial(column))
           render :partial => partial, :locals => {:column => column, :only_value => only_value, :scope => scope, :col_class => col_class, :record => record}
         elsif renders_as == :field || override_form_field?(column)
           form_attribute(column, record, scope, only_value, col_class)
@@ -179,12 +175,14 @@ module ActiveScaffold
         else
           field = active_scaffold_input_for column, scope, column_options
         end
+        if field
+          field << loading_indicator_tag(:action => :render_field, :id => params[:id]) if column.update_columns
+          field << content_tag(:span, column.description, :class => 'description') if column.description.present?
+        end
 
         content_tag :dl, attributes do
-          %(<dt>#{label_tag label_for(column, column_options), column.label}</dt><dd>#{field}
-#{loading_indicator_tag(:action => :render_field, :id => params[:id]) if column.update_columns}
-#{content_tag :span, column.description, :class => 'description' if column.description.present?}
-</dd>).html_safe
+          content_tag(:dt, label_tag(label_for(column, column_options), form_column_label(column))) <<
+            content_tag(:dd, field)
         end
       end
 
@@ -192,6 +190,10 @@ module ActiveScaffold
         options[:id] unless column.form_ui == :select && column.association&.collection?
       end
 
+      def form_column_label(column)
+        column.label
+      end
+
       def subform_label(column, hidden)
         column.label unless hidden
       end
@@ -276,9 +278,8 @@ module ActiveScaffold
       end
 
       def active_scaffold_select_name_with_multiple(options)
-        if options[:multiple] && !options[:name].to_s.ends_with?('[]')
-          options[:name] = "#{options[:name]}[]"
-        end
+        return if !options[:multiple] || options[:name].to_s.ends_with?('[]')
+        options[:name] = "#{options[:name]}[]"
       end
 
       def active_scaffold_input_singular_association(column, html_options, options = {})
@@ -303,10 +304,24 @@ module ActiveScaffold
             collection_select(:record, method, select_options, :id, column.options[:label_method] || :to_label, options, html_options)
           end
         html << active_scaffold_refresh_link(column, html_options, record) if column.options[:refresh_link]
+        html << active_scaffold_new_record_subform(column, record, html_options) if column.options[:add_new]
         html
       end
 
-      def active_scaffold_file_with_remove_link(column, options, content, remove_file_prefix, controls_class, &block)
+      def active_scaffold_new_record_subform(column, record, html_options)
+        subform_attrs = active_scaffold_subform_attributes(column).merge(style: 'display: none')
+        scope = html_options[:name].scan(/record(.*)\[#{column.name}\]/).dig(0, 0)
+        new_record = build_associated(column.association, record)
+        subform = render(partial: subform_partial_for_column(column), locals: {column: column, parent_record: record, associated: [], show_blank_record: new_record, scope: scope})
+        html = content_tag(:div, subform, subform_attrs)
+        html << active_scaffold_show_new_subform_link(column, record, html_options[:id], subform_attrs[:id])
+      end
+
+      def active_scaffold_show_new_subform_link(column, record, select_id, subform_id)
+        link_to(as_(:create_new), '#', data: {select_id: select_id, subform_id: subform_id, subform_text: as_(:add_existing)}, class: 'show-new-subform')
+      end
+
+      def active_scaffold_file_with_remove_link(column, options, content, remove_file_prefix, controls_class, &block) # rubocop:disable Metrics/ParameterLists
         options = active_scaffold_input_text_options(options.merge(column.options))
         if content
           active_scaffold_file_with_content(column, content, options, remove_file_prefix, controls_class, &block)
@@ -329,12 +344,13 @@ module ActiveScaffold
         object_name, method = options[:name].split(/\[(#{column.name})\]/)
         method.sub!(/#{column.name}/, "#{remove_file_prefix}\\0")
         fields = block_given? ? yield : ''
+        link_key = options[:multiple] ? :remove_files : :remove_file
         input = file_field(:record, column.name, options.merge(:onchange => js_dont_remove_file_code))
         content_tag(:div, class: controls_class) do
           content_tag(:div) do
             safe_join [content, ' | ', fields,
                        hidden_field(object_name, method, :value => 'false', class: 'remove_file'),
-                       content_tag(:a, as_(:remove_file), :href => '#', :onclick => js_remove_file_code)]
+                       content_tag(:a, as_(link_key), :href => '#', :onclick => js_remove_file_code)]
           end << content_tag(:div, input, :style => 'display: none')
         end
       end
@@ -385,11 +401,11 @@ module ActiveScaffold
         label_method = column.options[:label_method] || :to_label
         html = hidden_field_tag("#{options[:name]}[]", '', :id => nil)
         html << content_tag(:ul, options.merge(:class => "#{options[:class]} checkbox-list#{' draggable-lists' if column.options[:draggable_lists]}")) do
-          content = ''.html_safe
+          content = []
           select_options.each_with_index do |option, i|
             content << active_scaffold_checkbox_option(option, label_method, associated_ids, :name => "#{options[:name]}[]", :id => "#{options[:id]}_#{i}_id")
           end
-          content
+          safe_join content
         end
         html
       end
@@ -454,10 +470,20 @@ module ActiveScaffold
           end
 
         selected = record.send(column.association.name)&.id if column.association
-        radios = options.map do |option|
-          active_scaffold_radio_option(option, selected, column, html_options)
+        if options.present?
+          radios = options.map do |option|
+            active_scaffold_radio_option(option, selected, column, html_options)
+          end
+          if column.options[:include_blank]
+            label = column.options[:include_blank]
+            label = as_(column.options[:include_blank]) if column.options[:include_blank].is_a?(Symbol)
+            radios.prepend content_tag(:label, radio_button(:record, column.name, '', html_options.merge(id: nil)) + label)
+          end
+          safe_join radios
+        else
+          content_tag(:span, as_(:no_options), :class => "#{html_options[:class]} no-options", :id => html_options[:id]) <<
+            hidden_field_tag(html_options[:name], '', :id => nil)
         end
-        safe_join radios
       end
 
       def active_scaffold_input_checkbox(column, options)
@@ -519,16 +545,17 @@ module ActiveScaffold
 
       # A color picker
       def active_scaffold_input_color(column, options)
+        html = []
         options = active_scaffold_input_text_options(options)
         if column.column&.null
           no_color = options[:object].send(column.name).nil?
           method = no_color ? :hidden_field : :color_field
-          html = content_tag(:label, check_box_tag('disable', '1', no_color, id: nil, name: nil, class: 'no-color') << " #{as_ column.options[:no_color] || :no_color}")
+          html << content_tag(:label, check_box_tag('disable', '1', no_color, id: nil, name: nil, class: 'no-color') << " #{as_ column.options[:no_color] || :no_color}")
         else
           method = :color_field
-          html = ''.html_safe
         end
         html << send(method, :record, column.name, options.merge(column.options).except(:format, :no_color))
+        safe_join html
       end
 
       #
@@ -539,8 +566,8 @@ module ActiveScaffold
         record = options.delete(:object)
         select_options = []
         select_options << [as_(:_select_), nil] if !column.virtual? && column.column.null
-        select_options << [as_(:true), true]
-        select_options << [as_(:false), false]
+        select_options << [as_(:true), true] # rubocop:disable Lint/BooleanSymbol
+        select_options << [as_(:false), false] # rubocop:disable Lint/BooleanSymbol
 
         select_tag(options[:name], options_for_select(select_options, record.send(column.name)), options)
       end
@@ -636,12 +663,12 @@ module ActiveScaffold
           remote_controller = active_scaffold_controller_for(record_select_config.model).controller_path
           options[:controller] = remote_controller
           options.merge!(active_scaffold_input_text_options)
-          record_select_field(options[:name], record, options)
+          record_select_field(options[:name], nil, options)
         else
           select_options = sorted_association_options_find(nested.association, nil, record)
           select_options ||= active_scaffold_config.model.all
           select_options = options_from_collection_for_select(select_options, :id, :to_label)
-          select_tag 'associated_id', ('<option value="">' + as_(:_select_) + '</option>' + select_options).html_safe unless select_options.empty?
+          select_tag 'associated_id', (content_tag(:option, as_(:_select_), value: '') + select_options) unless select_options.empty?
         end
       end
 
@@ -654,55 +681,62 @@ module ActiveScaffold
       end
 
       # Try to get numerical constraints from model's validators
-      def numerical_constraints_for_column(column, options)
-        if column.numerical_constraints.nil?
-          numerical_constraints = {}
-          validators = column.active_record_class.validators.select do |v|
-            v.is_a?(ActiveModel::Validations::NumericalityValidator) && v.attributes.include?(column.name)
+      def column_numerical_constraints(column, options)
+        validators = column.active_record_class.validators.select do |v|
+          v.is_a?(ActiveModel::Validations::NumericalityValidator) && v.attributes.include?(column.name)
+        end
+
+        equal_validator = validators.find { |v| v.options[:equal_to] }
+        # If there is equal_to constraint - use it (unless otherwise specified by user)
+        if equal_validator && !(options[:min] || options[:max])
+          equal_to = equal_validator.options[:equal_to]
+          return {min: equal_to, max: equal_to}
+        end
+
+        numerical_constraints = {}
+
+        # find minimum and maximum from validators
+        # we can safely modify :min and :max by 1 for :greater_tnan or :less_than value only for integer values
+        only_integer = column.column.type == :integer if column.column
+        only_integer ||= validators.find { |v| v.options[:only_integer] }.present?
+        margin = only_integer ? 1 : 0
+
+        # Minimum
+        unless options[:min]
+          min = validators.map { |v| v.options[:greater_than_or_equal] }.compact.max
+          greater_than = validators.map { |v| v.options[:greater_than] }.compact.max
+          numerical_constraints[:min] = [min, (greater_than + margin if greater_than)].compact.max
+        end
+
+        # Maximum
+        unless options[:max]
+          max = validators.map { |v| v.options[:less_than_or_equal] }.compact.min
+          less_than = validators.map { |v| v.options[:less_than] }.compact.min
+          numerical_constraints[:max] = [max, (less_than - margin if less_than)].compact.min
+        end
+
+        # Set step = 2 for column values restricted to be odd or even (but only if minimum is set)
+        unless options[:step]
+          only_odd_valid  = validators.any? { |v| v.options[:odd] }
+          only_even_valid = validators.any? { |v| v.options[:even] } unless only_odd_valid
+          if !only_integer
+            numerical_constraints[:step] ||= "0.#{'0' * (column.column.scale - 1)}1" if column.column&.scale.to_i.positive?
+          elsif options[:min] && options[:min].respond_to?(:even?) && (only_odd_valid || only_even_valid)
+            numerical_constraints[:step] = 2
+            numerical_constraints[:min] += 1 if only_odd_valid  && options[:min].even?
+            numerical_constraints[:min] += 1 if only_even_valid && options[:min].odd?
           end
-          equal_to = (val = validators.find { |v| v.options[:equal_to] }) ? val.options[:equal_to] : nil
-
-          # If there is equal_to constraint - use it (unless otherwise specified by user)
-          if equal_to && !(options[:min] || options[:max])
-            numerical_constraints[:min] = numerical_constraints[:max] = equal_to
-          else # find minimum and maximum from validators
-            # we can safely modify :min and :max by 1 for :greater_tnan or :less_than value only for integer values
-            only_integer = column.column.type == :integer if column.column
-            only_integer ||= validators.find { |v| v.options[:only_integer] }.present?
-            margin = only_integer ? 1 : 0
-
-            # Minimum
-            unless options[:min]
-              min = validators.map { |v| v.options[:greater_than_or_equal] }.compact.max
-              greater_than = validators.map { |v| v.options[:greater_than] }.compact.max
-              numerical_constraints[:min] = [min, (greater_than + margin if greater_than)].compact.max
-            end
-
-            # Maximum
-            unless options[:max]
-              max = validators.map { |v| v.options[:less_than_or_equal] }.compact.min
-              less_than = validators.map { |v| v.options[:less_than] }.compact.min
-              numerical_constraints[:max] = [max, (less_than - margin if less_than)].compact.min
-            end
+          numerical_constraints[:step] ||= 'any' unless only_integer
+        end
 
-            # Set step = 2 for column values restricted to be odd or even (but only if minimum is set)
-            unless options[:step]
-              only_odd_valid  = validators.any? { |v| v.options[:odd] }
-              only_even_valid = validators.any? { |v| v.options[:even] } unless only_odd_valid
-              if !only_integer
-                numerical_constraints[:step] ||= "0.#{'0' * (column.column.scale - 1)}1" if column.column&.scale.to_i.positive?
-              elsif options[:min] && options[:min].respond_to?(:even?) && (only_odd_valid || only_even_valid)
-                numerical_constraints[:step] = 2
-                numerical_constraints[:min] += 1 if only_odd_valid  && options[:min].even?
-                numerical_constraints[:min] += 1 if only_even_valid && options[:min].odd?
-              end
-              numerical_constraints[:step] ||= 'any' unless only_integer
-            end
-          end
+        numerical_constraints
+      end
 
-          column.numerical_constraints = numerical_constraints
+      def numerical_constraints_for_column(column, options)
+        constraints = Rails.cache.fetch("#{column.cache_key}#numerical_constarints") do
+          column_numerical_constraints(column, options)
         end
-        column.numerical_constraints.merge(options)
+        constraints.merge(options)
       end
     end
   end