active_scaffold 3.7.0 → 3.7.2

data/lib/active_scaffold/helpers/list_column_helpers.rb

@@ -5,8 +5,13 @@ module ActiveScaffold
       def get_column_value(record, column)
         record = record.send(column.delegated_association.name) if column.delegated_association
         if record
-          method = get_column_method(record, column)
-          value = send(method, record, column)
+          method, list_ui = get_column_method(record, column)
+          value =
+            if list_ui
+              send(method, record, column, ui_options: column.list_ui_options || column.options)
+            else
+              send(method, record, column)
+            end
         else
           value = nil
         end
@@ -27,8 +32,8 @@ module ActiveScaffold
             method
           # second, check if the dev has specified a valid list_ui for this column
           elsif column.list_ui && (method = override_column_ui(column.list_ui))
-            method
-          elsif column.column && (method = override_column_ui(column.column.type))
+            [method, true]
+          elsif column.column && (method = override_column_ui(column.column_type))
             method
           else
             :format_column_value
@@ -76,39 +81,49 @@ module ActiveScaffold
       ##
       ## Overrides
       ##
-      def active_scaffold_column_text(record, column)
+      def active_scaffold_column_text(record, column, ui_options: column.options)
         # `to_s` is necessary to convert objects in serialized columns to string before truncation.
-        clean_column_value(truncate(record.send(column.name).to_s, :length => column.options[:truncate] || 50))
+        clean_column_value(truncate(record.send(column.name).to_s, length: ui_options[:truncate] || 50))
       end
 
-      def active_scaffold_column_fulltext(record, column)
+      def active_scaffold_column_fulltext(record, column, ui_options: column.options)
         clean_column_value(record.send(column.name))
       end
 
-      def active_scaffold_column_marked(record, column)
+      def active_scaffold_column_marked(record, column, ui_options: column.options)
         options = {:id => nil, :object => record}
         content_tag(:span, check_box(:record, column.name, options), :class => 'in_place_editor_field', :data => {:ie_id => record.to_param})
       end
 
-      def active_scaffold_column_checkbox(record, column)
+      def active_scaffold_column_checkbox(record, column, ui_options: column.options)
         options = {:disabled => true, :id => nil, :object => record}
         options.delete(:disabled) if inplace_edit?(record, column)
         check_box(:record, column.name, options)
       end
 
-      def active_scaffold_column_percentage(record, column)
-        options = column.options[:slider] || {}
+      def active_scaffold_column_boolean(record, column, ui_options: column.options)
+        value = record.send(column.name)
+        if value.nil? && ui_options[:include_blank]
+          value = ui_options[:include_blank]
+          value.is_a?(Symbol) ? as_(value) : value
+        else
+          format_column_value(record, column, value)
+        end
+      end
+
+      def active_scaffold_column_percentage(record, column, ui_options: column.options)
+        options = ui_options[:slider] || {}
         options = options.merge(min: record.send(options[:min_method])) if options[:min_method]
         options = options.merge(max: record.send(options[:max_method])) if options[:max_method]
         value = record.send(options[:value_method]) if options[:value_method]
         as_slider options.merge(value: value || record.send(column.name))
       end
 
-      def active_scaffold_column_month(record, column)
+      def active_scaffold_column_month(record, column, ui_options: column.options)
         l record.send(column.name), format: :year_month
       end
 
-      def active_scaffold_column_week(record, column)
+      def active_scaffold_column_week(record, column, ui_options: column.options)
         l record.send(column.name), format: :week
       end
 
@@ -119,10 +134,10 @@ module ActiveScaffold
         link_to text, "tel:#{[groups.join('-'), extension].compact.join(',')}"
       end
 
-      def active_scaffold_column_telephone(record, column)
+      def active_scaffold_column_telephone(record, column, ui_options: column.options)
         phone = record.send column.name
         return if phone.blank?
-        phone = number_to_phone(phone) unless column.options[:format] == false
+        phone = number_to_phone(phone) unless ui_options[:format] == false
         tel_to phone
       end
 
@@ -147,8 +162,9 @@ module ActiveScaffold
       def format_column_value(record, column, value = nil)
         value ||= record.send(column.name) unless record.nil?
         if column.association.nil?
-          if FORM_UI_WITH_OPTIONS.include?(column.form_ui) && column.options[:options]
-            text, val = column.options[:options].find { |t, v| (v.nil? ? t : v).to_s == value.to_s }
+          form_ui_options = column.form_ui_options || column.options if FORM_UI_WITH_OPTIONS.include?(column.form_ui)
+          if form_ui_options&.dig(:options)
+            text, val = form_ui_options[:options].find { |t, v| (v.nil? ? t : v).to_s == value.to_s }
             value = active_scaffold_translated_option(column, text, val).first if text
           end
           if grouped_search? && column == search_group_column && search_group_function
@@ -303,7 +319,7 @@ module ActiveScaffold
       end
 
       def inplace_edit_cloning?(column)
-        column.inplace_edit != :ajax && (override_form_field?(column) || column.form_ui || (column.column && override_input?(column.column.type)))
+        column.inplace_edit != :ajax && (override_form_field?(column) || column.form_ui || (column.column && override_input?(column.column_type)))
       end
 
       def active_scaffold_inplace_edit_tag_options(record, column)

data/lib/active_scaffold/helpers/search_column_helpers.rb

@@ -20,11 +20,11 @@ module ActiveScaffold
 
         # second, check if the dev has specified a valid search_ui for this column, using specific ui for searches
         elsif column.search_ui && (method = override_search(column.search_ui))
-          send(method, column, options)
+          send(method, column, options, ui_options: column.search_ui_options || column.options)
 
         # third, check if the dev has specified a valid search_ui for this column, using generic ui for forms
         elsif column.search_ui && (method = override_input(column.search_ui))
-          send(method, column, options)
+          send(method, column, options, ui_options: column.search_ui_options || column.options)
 
         # fourth, check if the dev has created an override for this specific field
         elsif (method = override_form_field(column))
@@ -34,11 +34,11 @@ module ActiveScaffold
         elsif column.association || column.virtual?
           active_scaffold_search_text(column, options)
 
-        elsif (method = override_search(column.column.type))
+        elsif (method = override_search(column.column_type))
           # if we (or someone else) have created a custom render option for the column type, use that
           send(method, column, options)
 
-        elsif (method = override_input(column.column.type))
+        elsif (method = override_input(column.column_type))
           # if we (or someone else) have created a custom render option for the column type, use that
           send(method, column, options)
 
@@ -73,28 +73,28 @@ module ActiveScaffold
       ## Search input methods
       ##
 
-      def active_scaffold_search_multi_select(column, options)
+      def active_scaffold_search_multi_select(column, options, ui_options: column.options)
         record = options.delete(:object)
         associated = options.delete :value
         associated = [associated].compact unless associated.is_a? Array
 
         if column.association
           associated.collect!(&:to_i)
-          method = column.options[:label_method] || :to_label
+          method = ui_options[:label_method] || :to_label
           select_options = sorted_association_options_find(column.association, nil, record).collect do |r|
             [r.send(method), r.id]
           end
         else
-          select_options = column.options[:options].collect do |text, value|
+          select_options = active_scaffold_enum_options(column, record, ui_options: ui_options).collect do |text, value|
             active_scaffold_translated_option(column, text, value)
           end
         end
         return as_(:no_options) if select_options.empty?
 
-        active_scaffold_checkbox_list(column, select_options, associated, options)
+        active_scaffold_checkbox_list(column, select_options, associated, options, ui_options: ui_options)
       end
 
-      def active_scaffold_search_select(column, html_options, options = {})
+      def active_scaffold_search_select(column, html_options, options = {}, ui_options: column.options)
         record = html_options.delete(:object)
         associated = html_options.delete :value
         if column.association
@@ -103,13 +103,13 @@ module ActiveScaffold
           select_options = sorted_association_options_find(column.association, false, record)
         else
           method = column.name
-          select_options = active_scaffold_enum_options(column, record).collect do |text, value|
+          select_options = active_scaffold_enum_options(column, record, ui_options: ui_options).collect do |text, value|
             active_scaffold_translated_option(column, text, value)
           end
         end
 
-        options = options.merge(:selected => associated).merge column.options
-        html_options.merge! column.options[:html_options] || {}
+        options = options.merge(selected: associated).merge ui_options
+        html_options.merge! ui_options[:html_options] || {}
         if html_options[:multiple]
           active_scaffold_select_name_with_multiple html_options
         else
@@ -120,23 +120,31 @@ module ActiveScaffold
         if (optgroup = options.delete(:optgroup))
           select(:record, method, active_scaffold_grouped_options(column, select_options, optgroup), options, html_options)
         elsif column.association
-          collection_select(:record, method, select_options, :id, column.options[:label_method] || :to_label, options, html_options)
+          collection_select(:record, method, select_options, :id, ui_options[:label_method] || :to_label, options, html_options)
         else
           select(:record, method, select_options, options, html_options)
         end
       end
 
-      def active_scaffold_search_text(column, options)
+      def active_scaffold_search_select_multiple(column, options, ui_options: column.options)
+        active_scaffold_search_select(column, options.merge(multiple: true), ui_options: ui_options)
+      end
+
+      def active_scaffold_search_draggable(column, options, ui_options: column.options)
+        active_scaffold_search_multi_select(column, options.merge(draggable_lists: true), ui_options: ui_options)
+      end
+
+      def active_scaffold_search_text(column, options, ui_options: column.options)
         text_field :record, column.name, active_scaffold_input_text_options(options)
       end
 
       # we can't use active_scaffold_input_boolean because we need to have a nil value even when column can't be null
       # to decide whether search for this field or not
-      def active_scaffold_search_boolean(column, options)
+      def active_scaffold_search_boolean(column, options, ui_options: column.options)
         select_options = []
         select_options << [as_(:_select_), nil]
-        if column.column&.null
-          null_label = column.options[:include_blank] || :null
+        if column.null?
+          null_label = ui_options[:include_blank] || :null
           null_label = as_(null_label) if null_label.is_a?(Symbol)
           select_options << [null_label, 'null']
         end
@@ -168,7 +176,7 @@ module ActiveScaffold
         end
       end
 
-      def active_scaffold_search_null(column, options)
+      def active_scaffold_search_null(column, options, ui_options: column.options)
         select_options = []
         select_options << [as_(:_select_), nil]
         select_options.concat(ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] })
@@ -185,38 +193,38 @@ module ActiveScaffold
         column.text? || column.search_ui == :string
       end
 
-      def active_scaffold_search_range_comparator_options(column)
+      def active_scaffold_search_range_comparator_options(column, ui_options: column.options)
         select_options = ActiveScaffold::Finder::NUMERIC_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
         if active_scaffold_search_range_string?(column)
           comparators = ActiveScaffold::Finder::STRING_COMPARATORS.collect { |title, comp| [as_(title), comp] }
           select_options.unshift(*comparators)
         end
-        if include_null_comparators? column
+        if include_null_comparators? column, ui_options: ui_options
           select_options.concat(ActiveScaffold::Finder::NULL_COMPARATORS.collect { |comp| [as_(comp), comp] })
         end
         select_options
       end
 
-      def include_null_comparators?(column)
-        return column.options[:null_comparators] if column.options.key? :null_comparators
+      def include_null_comparators?(column, ui_options: column.options)
+        return ui_options[:null_comparators] if ui_options.key? :null_comparators
         if column.association
-          !column.association.belongs_to? || active_scaffold_config.columns[column.association.foreign_key].column&.null
+          !column.association.belongs_to? || active_scaffold_config.columns[column.association.foreign_key].null?
         else
-          column.column&.null
+          column.null?
         end
       end
 
-      def active_scaffold_search_range(column, options, input_method = :text_field_tag, input_options = {})
+      def active_scaffold_search_range(column, options, input_method = :text_field_tag, input_options = {}, ui_options: column.options)
         opt_value, from_value, to_value = field_search_params_range_values(column)
 
-        select_options = active_scaffold_search_range_comparator_options(column)
+        select_options = active_scaffold_search_range_comparator_options(column, ui_options: ui_options)
         text_field_size = active_scaffold_search_range_string?(column) ? 15 : 10
         opt_value ||= select_options[0][1]
 
         from_value = controller.class.condition_value_for_numeric(column, from_value)
         to_value = controller.class.condition_value_for_numeric(column, to_value)
-        from_value = format_number_value(from_value, column.options) if from_value.is_a?(Numeric)
-        to_value = format_number_value(to_value, column.options) if to_value.is_a?(Numeric)
+        from_value = format_number_value(from_value, ui_options) if from_value.is_a?(Numeric)
+        to_value = format_number_value(to_value, ui_options) if to_value.is_a?(Numeric)
         html = select_tag("#{options[:name]}[opt]", options_for_select(select_options, opt_value),
                           :id => "#{options[:id]}_opt", :class => 'as_search_range_option')
         from_options = active_scaffold_input_text_options(input_options.merge(:id => options[:id], :size => text_field_size))
@@ -233,51 +241,119 @@ module ActiveScaffold
       end
       alias active_scaffold_search_string active_scaffold_search_range
 
-      def active_scaffold_search_integer(column, options)
-        active_scaffold_search_range(column, options, :number_field_tag, step: '1')
+      def active_scaffold_search_integer(column, options, ui_options: column.options)
+        active_scaffold_search_range(column, options, :number_field_tag, {step: '1'}, ui_options: ui_options) # rubocop:disable Style/BracesAroundHashParameters
       end
 
-      def active_scaffold_search_decimal(column, options)
-        active_scaffold_search_range(column, options, :number_field_tag, step: :any)
+      def active_scaffold_search_decimal(column, options, ui_options: column.options)
+        active_scaffold_search_range(column, options, :number_field_tag, {step: :any}, ui_options: ui_options) # rubocop:disable Style/BracesAroundHashParameters
       end
       alias active_scaffold_search_float active_scaffold_search_decimal
 
+      def active_scaffold_search_datetime(column, options, ui_options: column.options, field_ui: column.search_ui || :datetime)
+        current_search = {'from' => nil, 'to' => nil, 'opt' => 'BETWEEN',
+                          'number' => 1, 'unit' => 'DAYS', 'range' => nil}
+        current_search.merge!(options[:value]) unless options[:value].nil?
+        tags = [
+          active_scaffold_search_datetime_comparator_tag(column, options, current_search),
+          active_scaffold_search_datetime_trend_tag(column, options, current_search),
+          active_scaffold_search_datetime_numeric_tag(column, options, current_search, ui_options: ui_options, field_ui: field_ui),
+          active_scaffold_search_datetime_range_tag(column, options, current_search)
+        ]
+        safe_join tags, '&nbsp;'.html_safe # rubocop:disable Rails/OutputSafety
+      end
+
+      def active_scaffold_search_timestamp(column, options, ui_options: column.options)
+        active_scaffold_search_datetime(column, options, ui_options: ui_options, field_ui: :datetime)
+      end
+
+      def active_scaffold_search_time(column, options, ui_options: column.options)
+        active_scaffold_search_datetime(column, options, ui_options: ui_options, field_ui: :time)
+      end
+
+      def active_scaffold_search_date(column, options, ui_options: column.options)
+        active_scaffold_search_datetime(column, options, ui_options: ui_options, field_ui: :date)
+      end
+
+      def active_scaffold_search_datetime_comparator_options(column)
+        select_options = ActiveScaffold::Finder::DATE_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
+        select_options + ActiveScaffold::Finder::NUMERIC_COMPARATORS.collect { |comp| [as_(comp.downcase.to_sym), comp] }
+      end
+
+      def active_scaffold_search_datetime_comparator_tag(column, options, current_search)
+        choices = options_for_select(active_scaffold_search_datetime_comparator_options(column), current_search['opt'])
+        select_tag("#{options[:name]}[opt]", choices, id: "#{options[:id]}_opt", class: 'as_search_range_option as_search_date_time_option')
+      end
+
+      def active_scaffold_search_datetime_numeric_tag(column, options, current_search, ui_options: column.options, field_ui: column.search_ui)
+        helper = "active_scaffold_search_#{field_ui}_field"
+        numeric_controls = [
+          send(helper, column, options, current_search, 'from', ui_options: ui_options),
+          content_tag(:span, id: "#{options[:id]}_between", class: 'as_search_range_between',
+                             style: ('display: none' unless current_search['opt'] == 'BETWEEN')) do
+            safe_join([' - ', send(helper, column, options, current_search, 'to', ui_options: ui_options)])
+          end
+        ]
+        content_tag('span', safe_join(numeric_controls),
+                    :id => "#{options[:id]}_numeric", :class => 'search-date-numeric',
+                    :style => ActiveScaffold::Finder::NUMERIC_COMPARATORS.include?(current_search['opt']) ? nil : 'display: none')
+      end
+
+      def active_scaffold_search_datetime_trend_tag(column, options, current_search)
+        trend_controls = [
+          text_field_tag("#{options[:name]}[number]", current_search['number'], class: 'text-input', size: 10, autocomplete: 'off'),
+          select_tag("#{options[:name]}[unit]",
+                     options_for_select(active_scaffold_search_datetime_trend_units(column), current_search['unit']),
+                     class: 'text-input')
+        ]
+        content_tag('span', safe_join(trend_controls, ' '),
+                    id: "#{options[:id]}_trend", class: 'search-date-trend',
+                    style: ('display: none' unless current_search['opt'] == 'PAST' || current_search['opt'] == 'FUTURE'))
+      end
+
+      def active_scaffold_search_datetime_trend_units(column)
+        options = ActiveScaffold::Finder::DATE_UNITS.collect { |unit| [as_(unit.downcase.to_sym), unit] }
+        options = ActiveScaffold::Finder::TIME_UNITS.collect { |unit| [as_(unit.downcase.to_sym), unit] } + options if column_datetime?(column)
+        options
+      end
+
+      def active_scaffold_search_datetime_range_tag(column, options, current_search)
+        values = ActiveScaffold::Finder::DATE_RANGES.collect { |range| [as_(range.downcase.to_sym), range] }
+        range_controls = select_tag("#{options[:name]}[range]",
+                                    options_for_select(values, current_search['range']),
+                                    class: 'text-input', id: nil)
+        content_tag('span', range_controls,
+                    id: "#{options[:id]}_range", class: 'search-date-range',
+                    style: ('display: none' unless current_search['opt'] == 'RANGE'))
+      end
+
+      def column_datetime?(column)
+        (!column.column.nil? && %i[datetime time].include?(column.column_type))
+      end
+
       def field_search_datetime_value(value)
         Time.zone.local(value[:year].to_i, value[:month].to_i, value[:day].to_i, value[:hour].to_i, value[:minute].to_i, value[:second].to_i) unless value.nil? || value[:year].blank?
       end
 
-      def active_scaffold_search_datetime(column, options)
-        _, from_value, to_value = field_search_params_range_values(column)
-        options = column.options.merge(options)
+      def active_scaffold_search_datetime_field(column, options, current_search, name, ui_options: column.options)
+        options = ui_options.merge(options)
         type = "#{'date' unless options[:discard_date]}#{'time' unless options[:discard_time]}"
-        use_select = options.delete(:use_select)
-        from_name = "#{options[:name]}[from]"
-        to_name = "#{options[:name]}[to]"
-        if use_select
-          helper = "select_#{type}"
-          fields = [
-            send(helper, field_search_datetime_value(from_value), options.reverse_merge(include_blank: true, prefix: from_name)),
-            send(helper, field_search_datetime_value(to_value), options.reverse_merge(include_blank: true, prefix: to_name))
-          ]
+        field_name = "#{options[:name]}[#{name}]"
+        if options[:use_select]
+          send("select_#{type}", current_search[name], options.reverse_merge(include_blank: true, prefix: field_name))
         else
           helper = "#{type}#{'_local' if type == 'datetime'}_field_tag"
-          fields = [
-            send(helper, from_name, field_search_datetime_value(from_value), options.except(:name, :object).merge(id: "#{options[:id]}_from")),
-            send(helper, to_name, field_search_datetime_value(to_value), options.except(:name, :object).merge(id: "#{options[:id]}_to"))
-          ]
+          send(helper, field_name, current_search[name], options.except(:name, :object, :use_select).merge(id: "#{options[:id]}_#{name}"))
         end
-
-        safe_join fields, ' - '
       end
 
-      def active_scaffold_search_date(column, options)
-        active_scaffold_search_datetime(column, options.merge!(:discard_time => true))
+      def active_scaffold_search_date_field(column, options, current_search, name, ui_options: column.options)
+        active_scaffold_search_datetime_field(column, options.merge!(:discard_time => true), current_search, name, ui_options: ui_options)
       end
 
-      def active_scaffold_search_time(column, options)
-        active_scaffold_search_datetime(column, options.merge!(:discard_date => true))
+      def active_scaffold_search_time_field(column, options, current_search, name, ui_options: column.options)
+        active_scaffold_search_datetime_field(column, options.merge!(:discard_date => true), current_search, name, ui_options: ui_options)
       end
-      alias active_scaffold_search_timestamp active_scaffold_search_datetime
 
       ##
       ## Search column override signatures

data/lib/active_scaffold/helpers/show_column_helpers.rb

@@ -13,24 +13,24 @@ module ActiveScaffold
           send(method, value_record, column)
         # second, check if the dev has specified a valid list_ui for this column
         elsif column.show_ui && (method = override_show_column_ui(column.show_ui))
-          send(method, value_record, column)
-        elsif column.column && (method = override_show_column_ui(column.column.type))
+          send(method, value_record, column, ui_options: column.show_ui_options || column.options)
+        elsif column.column && (method = override_show_column_ui(column.column_type))
           send(method, value_record, column)
         else
           get_column_value(record, column)
         end
       end
 
-      def active_scaffold_show_text(record, column)
-        simple_format(clean_column_value(record.send(column.name)))
+      def active_scaffold_show_text(record, column, ui_options: column.options)
+        simple_format(clean_column_value(record.send(column.name)), ui_options[:html_options], ui_options)
       end
 
-      def active_scaffold_show_horizontal(record, column)
+      def active_scaffold_show_horizontal(record, column, ui_options: column.options)
         raise ':horizontal show_ui must be used on association column' unless column.association
         render :partial => 'show_association', :locals => {:column => column, :parent_record => record, :show_partial => :horizontal}
       end
 
-      def active_scaffold_show_vertical(record, column)
+      def active_scaffold_show_vertical(record, column, ui_options: column.options)
         raise ':vertical show_ui must be used on association column' unless column.association
         render :partial => 'show_association', :locals => {:column => column, :parent_record => record, :show_partial => :vertical}
       end

data/lib/active_scaffold/orm_checks.rb

@@ -82,6 +82,22 @@ module ActiveScaffold
           type_for_attribute(klass, column_name)
         end
       end
+
+      def default_value(klass, column_name)
+        if ActiveScaffold::OrmChecks.mongoid? klass
+          columns_hash(klass)[column_name]&.default_val
+        elsif ActiveScaffold::OrmChecks.active_record? klass
+          klass._default_attributes[column_name]&.value
+        end
+      end
+
+      def cast(klass, column_name, value)
+        if active_record? klass
+          type_for_attribute(klass, column_name).cast value
+        elsif mongoid? klass
+          type_for_attribute(klass, column_name)&.evolve value
+        end
+      end
     end
 
     %i[active_record? mongoid? tableless?].each do |method|
@@ -96,10 +112,14 @@ module ActiveScaffold
       end
     end
 
-    %i[type_for_attribute column_type].each do |method|
+    %i[type_for_attribute column_type default_value].each do |method|
       define_method method do |column_name|
         ActiveScaffold::OrmChecks.send method, active_record_class, column_name
       end
     end
+
+    def cast(column_name, value)
+      ActiveScaffold::OrmChecks.cast active_record_class, column_name, value
+    end
   end
 end

data/lib/active_scaffold/version.rb

@@ -2,7 +2,7 @@ module ActiveScaffold
   module Version
     MAJOR = 3
     MINOR = 7
-    PATCH = 0
+    PATCH = 2
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/active_scaffold.rb

@@ -3,6 +3,7 @@ module ActiveScaffold
   autoload :AttributeParams, 'active_scaffold/attribute_params'
   autoload :Bridges, 'active_scaffold/bridges'
   autoload :Configurable, 'active_scaffold/configurable'
+  autoload :ConnectionAdapters, 'active_scaffold/extensions/connection_adapter.rb'
   autoload :Constraints, 'active_scaffold/constraints'
   autoload :Core, 'active_scaffold/core'
   autoload :Finder, 'active_scaffold/finder'
@@ -10,6 +11,7 @@ module ActiveScaffold
   autoload :OrmChecks, 'active_scaffold/orm_checks'
   autoload :Registry, 'active_scaffold/registry'
   autoload :RespondsToParent, 'active_scaffold/responds_to_parent'
+  autoload :Routing, 'active_scaffold/extensions/routing_mapper'
   autoload :Tableless, 'active_scaffold/tableless'
   autoload :Version, 'active_scaffold/version'
 
@@ -78,6 +80,8 @@ module ActiveScaffold
     @@exclude_bridges ||= []
   end
 
+  mattr_accessor :nested_subforms, instance_writer: false
+
   def self.root
     File.dirname(__FILE__) + '/..'
   end
@@ -90,5 +94,3 @@ require 'active_scaffold/engine'
 require 'ice_nine'
 require 'ice_nine/core_ext/object'
 require 'request_store'
-# TODO: clean up extensions. some could be organized for autoloading, and others could be removed entirely.
-Dir["#{File.dirname __FILE__}/active_scaffold/extensions/*.rb"].each { |file| require file }

data/test/bridges/date_picker_test.rb

@@ -24,7 +24,8 @@ class DatePickerTest < ActionView::TestCase
   def test_form_ui
     config = ActiveScaffold::Config::Core.new(:company)
     @record = Company.new
-    assert active_scaffold_input_date_picker(config.columns[:date], :name => 'record[date]', :id => 'record_date', :object => @record)
-    assert active_scaffold_input_date_picker(config.columns[:datetime], :name => 'record[datetime]', :id => 'record_datetime', :object => @record)
+    opts = {object: @record}
+    assert active_scaffold_input_date_picker(config.columns[:date], opts.merge(id: 'record_date', name: 'record[date]'))
+    assert active_scaffold_input_date_picker(config.columns[:datetime], opts.merge(id: 'record_date', name: 'record[datetime]'))
   end
 end

data/test/bridges/paperclip_test.rb

@@ -58,11 +58,12 @@ class PaperclipTest < ActionView::TestCase
     with_js_framework :jquery do
       config = PaperclipCore.new(:company)
       @record = Company.new
+      opts = {name: 'record[logo]', id: 'record_logo', object: @record}
 
       @record.stubs(:logo).returns(stub(:file? => true, :original_filename => 'file', :url => '/system/file', :styles => Company.attachment_definitions[:logo]))
       click_js = "jQuery(this).prev().val('true'); jQuery(this).parent().hide().next().show(); return false;"
       change_js = "jQuery(this).parents('div.paperclip_controls').find('input.remove_file').val('false'); return false;"
-      @document = Nokogiri::HTML::Document.parse(active_scaffold_input_paperclip(config.columns[:logo], :name => 'record[logo]', :id => 'record_logo', :object => @record))
+      @document = Nokogiri::HTML::Document.parse(active_scaffold_input_paperclip(config.columns[:logo], opts))
       assert_select 'div.paperclip_controls input[type=file]' do |match|
         assert_equal match[0]['onchange'], change_js
       end
@@ -72,7 +73,7 @@ class PaperclipTest < ActionView::TestCase
       assert_select 'div.paperclip_controls input.remove_file[type=hidden][value=false]'
 
       @record.stubs(:logo).returns(stub(:file? => false))
-      assert_dom_equal '<input name="record[logo]" class="text-input" autocomplete="off" type="file" id="record_logo" />', active_scaffold_input_paperclip(config.columns[:logo], :name => 'record[logo]', :id => 'record_logo', :object => @record)
+      assert_dom_equal '<input name="record[logo]" class="text-input" autocomplete="off" type="file" id="record_logo" />', active_scaffold_input_paperclip(config.columns[:logo], opts)
     end
   end
 

data/test/bridges/tiny_mce_test.rb

@@ -35,16 +35,18 @@ class TinyMceTest < ActionView::TestCase
   def test_form_ui
     config = ActiveScaffold::Config::Core.new(:company)
     record = Company.new
+    opts = {name: 'record[name]', id: 'record_name', class: 'name-input', object: record}
 
-    assert_dom_equal %(<textarea name=\"record[name]\" class=\"name-input mceEditor\" id=\"record_name\" data-tinymce=\"{&quot;theme&quot;:&quot;modern&quot;}\">\n</textarea>), active_scaffold_input_text_editor(config.columns[:name], :name => 'record[name]', :id => 'record_name', :class => 'name-input', :object => record)
+    assert_dom_equal %(<textarea name=\"record[name]\" class=\"name-input mceEditor\" id=\"record_name\" data-tinymce=\"{&quot;theme&quot;:&quot;modern&quot;}\">\n</textarea>), active_scaffold_input_text_editor(config.columns[:name], opts)
   end
 
   def test_form_ui_alternate
     config = ActiveScaffold::Config::Core.new(:company)
     record = Company.new
     config.columns[:name].options[:tinymce_config] = :alternate
+    opts = {name: 'record[name]', id: 'record_name', class: 'name-input', object: record}
 
-    assert_dom_equal %(<textarea name=\"record[name]\" class=\"name-input mceEditor\" id=\"record_name\" data-tinymce=\"{&quot;theme&quot;:&quot;alternate&quot;,&quot;toolbar&quot;:&quot;undo redo | format&quot;}\">\n</textarea>), active_scaffold_input_tinymce(config.columns[:name], :name => 'record[name]', :id => 'record_name', :class => 'name-input', :object => record)
+    assert_dom_equal %(<textarea name=\"record[name]\" class=\"name-input mceEditor\" id=\"record_name\" data-tinymce=\"{&quot;theme&quot;:&quot;alternate&quot;,&quot;toolbar&quot;:&quot;undo redo | format&quot;}\">\n</textarea>), active_scaffold_input_tinymce(config.columns[:name], opts)
   end
 
   protected

data/test/helpers/form_column_helpers_test.rb

@@ -9,23 +9,25 @@ class FormColumnHelpersTest < ActionView::TestCase
   end
 
   def test_choices_for_select_form_ui_for_simple_column
+    opts = {object: @record}
     @column.options[:options] = %i[value_1 value_2 value_3]
-    assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">Value 1</option>\n<option value=\"value_2\">Value 2</option>\n<option value=\"value_3\">Value 3</option></select>", active_scaffold_input_select(@column, :object => @record)
+    assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">Value 1</option>\n<option value=\"value_2\">Value 2</option>\n<option value=\"value_3\">Value 3</option></select>", active_scaffold_input_select(@column, opts.dup)
 
     @column.options[:options] = %w[value_1 value_2 value_3]
-    assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">value_1</option>\n<option value=\"value_2\">value_2</option>\n<option value=\"value_3\">value_3</option></select>", active_scaffold_input_select(@column, :object => @record)
+    assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">value_1</option>\n<option value=\"value_2\">value_2</option>\n<option value=\"value_3\">value_3</option></select>", active_scaffold_input_select(@column, opts.dup)
 
     @column.options[:options] = [%w[text_1 value_1], %w[text_2 value_2], %w[text_3 value_3]]
-    assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">text_1</option>\n<option value=\"value_2\">text_2</option>\n<option value=\"value_3\">text_3</option></select>", active_scaffold_input_select(@column, :object => @record)
+    assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">text_1</option>\n<option value=\"value_2\">text_2</option>\n<option value=\"value_3\">text_3</option></select>", active_scaffold_input_select(@column, opts.dup)
 
     @column.options[:options] = [%i[text_1 value_1], %i[text_2 value_2], %i[text_3 value_3]]
-    assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">Text 1</option>\n<option value=\"value_2\">Text 2</option>\n<option value=\"value_3\">Text 3</option></select>", active_scaffold_input_select(@column, :object => @record)
+    assert_dom_equal "<select name=\"record[a]\" id=\"record_a\"><option value=\"value_1\">Text 1</option>\n<option value=\"value_2\">Text 2</option>\n<option value=\"value_3\">Text 3</option></select>", active_scaffold_input_select(@column, opts.dup)
   end
 
   def test_options_for_select_form_ui_for_simple_column
+    opts = {object: @record}
     @column.options = {:include_blank => 'None', :selected => 'value_2', :disabled => %w[value_1 value_3]}
     @column.options[:options] = %w[value_1 value_2 value_3]
     @column.options[:html_options] = {:class => 'big'}
-    assert_dom_equal "<select name=\"record[a]\" class=\"big\" id=\"record_a\"><option value=\"\">None</option>\n<option disabled=\"disabled\" value=\"value_1\">value_1</option>\n<option selected=\"selected\" value=\"value_2\">value_2</option>\n<option disabled=\"disabled\" value=\"value_3\">value_3</option></select>", active_scaffold_input_select(@column, :object => @record)
+    assert_dom_equal "<select name=\"record[a]\" class=\"big\" id=\"record_a\"><option value=\"\">None</option>\n<option disabled=\"disabled\" value=\"value_1\">value_1</option>\n<option selected=\"selected\" value=\"value_2\">value_2</option>\n<option disabled=\"disabled\" value=\"value_3\">value_3</option></select>", active_scaffold_input_select(@column, opts)
   end
 end