brisk-bills 0.7.0 → 0.8.1

data/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/association_helpers.rb

@@ -1,40 +1,40 @@
-module ActiveScaffold
-  module Helpers
-    module AssociationHelpers
-      # Provides a way to honor the :conditions on an association while searching the association's klass
-      def association_options_find(association, conditions = nil)
-        association.klass.find(:all, :conditions => controller.send(:merge_conditions, conditions, association.options[:conditions]))
-      end
-
-      def association_options_count(association, conditions = nil)
-        association.klass.count(:all, :conditions => controller.send(:merge_conditions, conditions, association.options[:conditions]))
-      end
-
-      # returns options for the given association as a collection of [id, label] pairs intended for the +options_for_select+ helper.
-      def options_for_association(association, include_all = false)
-        available_records = association_options_find(association, include_all ? nil : options_for_association_conditions(association))
-        available_records ||= []
-        available_records.sort{|a,b| a.to_label <=> b.to_label}.collect { |model| [ model.to_label, model.id ] }
-      end
-
-      def options_for_association_count(association)
-        association_options_count(association, options_for_association_conditions(association))
-      end
-
-      # A useful override for customizing the records present in an association dropdown.
-      # Should work in both the subform and form_ui=>:select modes.
-      # Check association.name to specialize the conditions per-column.
-      def options_for_association_conditions(association)
-        return nil if association.options[:through]
-        case association.macro
-          when :has_one, :has_many
-            # Find only orphaned objects
-            "#{association.primary_key_name} IS NULL"
-          when :belongs_to, :has_and_belongs_to_many
-            # Find all
-            nil
-        end
-      end
-    end
-  end
-end
+module ActiveScaffold
+  module Helpers
+    module AssociationHelpers
+      # Provides a way to honor the :conditions on an association while searching the association's klass
+      def association_options_find(association, conditions = nil)
+        association.klass.find(:all, :conditions => controller.send(:merge_conditions, conditions, association.options[:conditions]))
+      end
+
+      def association_options_count(association, conditions = nil)
+        association.klass.count(:all, :conditions => controller.send(:merge_conditions, conditions, association.options[:conditions]))
+      end
+
+      # returns options for the given association as a collection of [id, label] pairs intended for the +options_for_select+ helper.
+      def options_for_association(association, include_all = false)
+        available_records = association_options_find(association, include_all ? nil : options_for_association_conditions(association))
+        available_records ||= []
+        available_records.sort{|a,b| a.to_label <=> b.to_label}.collect { |model| [ model.to_label, model.id ] }
+      end
+
+      def options_for_association_count(association)
+        association_options_count(association, options_for_association_conditions(association))
+      end
+
+      # A useful override for customizing the records present in an association dropdown.
+      # Should work in both the subform and form_ui=>:select modes.
+      # Check association.name to specialize the conditions per-column.
+      def options_for_association_conditions(association)
+        return nil if association.options[:through]
+        case association.macro
+          when :has_one, :has_many
+            # Find only orphaned objects
+            "#{association.primary_key_name} IS NULL"
+          when :belongs_to, :has_and_belongs_to_many
+            # Find all
+            nil
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/controller_helpers.rb

@@ -1,25 +1,40 @@
-module ActiveScaffold
-  module Helpers
-    module ControllerHelpers
-      def self.included(controller)
-        controller.class_eval { helper_method :params_for }
-      end
-      
-      include ActiveScaffold::Helpers::IdHelpers
-      
-      def params_for(options = {})
-        # :adapter and :position are one-use rendering arguments. they should not propagate.
-        # :sort, :sort_direction, and :page are arguments that stored in the session. they need not propagate.
-        # and wow. no we don't want to propagate :record.
-        # :commit is a special rails variable for form buttons
-        blacklist = [:adapter, :position, :sort, :sort_direction, :page, :record, :commit, :_method]
-        unless @params_for
-          @params_for = params.clone.delete_if { |key, value| blacklist.include? key.to_sym if key }
-          @params_for[:controller] = '/' + @params_for[:controller] unless @params_for[:controller].first(1) == '/' # for namespaced controllers
-          @params_for.delete(:id) if @params_for[:id].nil?
-        end
-        @params_for.merge(options)
-      end
-    end
-  end
+module ActiveScaffold
+  module Helpers
+    module ControllerHelpers
+      def self.included(controller)
+        controller.class_eval { helper_method :params_for, :main_path_to_return }
+      end
+      
+      include ActiveScaffold::Helpers::IdHelpers
+      
+      def params_for(options = {})
+        # :adapter and :position are one-use rendering arguments. they should not propagate.
+        # :sort, :sort_direction, and :page are arguments that stored in the session. they need not propagate.
+        # and wow. no we don't want to propagate :record.
+        # :commit is a special rails variable for form buttons
+        blacklist = [:adapter, :position, :sort, :sort_direction, :page, :record, :commit, :_method, :authenticity_token, :format]
+        unless @params_for
+          @params_for = params.clone.delete_if { |key, value| blacklist.include? key.to_sym if key }
+          @params_for[:controller] = '/' + @params_for[:controller] unless @params_for[:controller].first(1) == '/' # for namespaced controllers
+          @params_for.delete(:id) if @params_for[:id].nil?
+        end
+        @params_for.merge(options)
+      end
+
+      # Parameters to generate url to the main page (override if the ActiveScaffold is used as a component on another controllers page)
+      def main_path_to_return
+        parameters = {}
+        if params[:parent_controller]
+          parameters[:controller] = params[:parent_controller]
+          parameters[:eid] = params[:parent_controller]
+        end
+        parameters[:nested] = nil
+        parameters[:parent_column] = nil
+        parameters[:parent_id] = nil
+        parameters[:action] = "index"
+        parameters[:id] = nil
+        params_for(parameters)
+      end
+    end
+  end
 end

data/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/country_helpers.rb

@@ -1,5 +1,3 @@
-I18n.load_path << File.dirname(__FILE__) + '/../../../lib/active_scaffold/locale/en-countries.yml'
-
 module ActiveScaffold
   module Helpers
     module CountryHelpers
@@ -18,14 +16,13 @@ module ActiveScaffold
       #
       # NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
       def country_options_for_select(selected = nil, priority_countries = nil)
-        country_options = ""
-
         if priority_countries
-          country_options += options_for_select(priority_countries, selected)
-          country_options += "<option value=\"\" disabled=\"disabled\">-------------</option>\n"
+          country_options = options_for_select(priority_countries.collect {|country| [I18n.t("countries.#{country}", :default => country.to_s.titleize), country.to_s]} + [['-------------', '']], :selected => selected, :disabled => '')
+        else
+          country_options = ""
         end
 
-        return country_options + options_for_select(COUNTRIES.collect {|country| [I18n.t("countries.#{country}"), country]}, selected)
+        return country_options + options_for_select(COUNTRIES.collect {|country| [I18n.t("countries.#{country}", :default => country.to_s.titleize), country.to_s]}, :selected => selected)
       end
 
       # Returns a string of option tags for the states in the United States. Supply a state name as +selected to
@@ -33,16 +30,16 @@ module ActiveScaffold
       # in case you want to highligh a local area
       # NOTE: Only the option tags are returned from this method, wrap it in a <select>
       def usa_state_options_for_select(selected = nil, priority_states = nil)
-        state_options = ""
         if priority_states
-          state_options += options_for_select(priority_states, selected)
-          state_options += "<option>-------------</option>\n"
+          state_options = options_for_select(priority_states + [['-------------', '']], :selected => selected, :disabled => '')
+        else
+          state_options = ""
         end
 
         if priority_states && priority_states.include?(selected)
-          state_options += options_for_select(USASTATES - priority_states, selected)
+          state_options += options_for_select(USASTATES - priority_states, :selected => selected)
         else
-          state_options += options_for_select(USASTATES, selected)
+          state_options += options_for_select(USASTATES, :selected => selected)
         end
 
         return state_options
@@ -305,10 +302,11 @@ module ActiveScaffold
           html_options = html_options.stringify_keys
           add_default_name_and_id(html_options)
           value = value(object)
+          selected_value = options.has_key?(:selected) ? options[:selected] : value
           content_tag("select",
             add_options(
-              country_options_for_select(value, priority_countries),
-              options, value
+              country_options_for_select(selected_value, priority_countries),
+              options, selected_value
             ), html_options
           )
         end
@@ -316,33 +314,39 @@ module ActiveScaffold
         def to_usa_state_select_tag(priority_states, options, html_options)
           html_options = html_options.stringify_keys
           add_default_name_and_id(html_options)
-          value = value(object) if method(:value).arity > 0
-          if html_options[:name.to_s].include?('search')
-            html_options[:name.to_s] << '[]' 
-            html_options[:multiple] = true
-            options[:include_blank] = true
-          end
-          content_tag("select", add_options(usa_state_options_for_select(value, priority_states), options, value), html_options)
+          value = value(object)
+          selected_value = options.has_key?(:selected) ? options[:selected] : value
+          content_tag("select", add_options(usa_state_options_for_select(selected_value, priority_states), options, selected_value), html_options)
         end
       end
     end
     
     module FormColumnHelpers
       def active_scaffold_input_country(column, options)
-        priority = ["United States"]
         select_options = {:prompt => as_(:_select_)}
         select_options.merge!(options)
-        country_select(:record, column.name, column.options[:priority] || priority, select_options, column.options)
+        options.reverse_merge!(column.options).except!(:prompt, :priority)
+        options[:name] += '[]' if options[:multiple]
+        country_select(:record, column.name, column.options[:priority] || [:united_states], select_options, options)
       end
 
       def active_scaffold_input_usa_state(column, options)
         select_options = {:prompt => as_(:_select_)}
         select_options.merge!(options)
-        select_options.delete(:size)
-        options.delete(:prompt)
-        options.delete(:priority)
-        usa_state_select(:record, column.name, column.options[:priority], select_options, column.options.merge!(options))
+        options.reverse_merge!(column.options).except!(:prompt, :priority)
+        options[:name] += '[]' if options[:multiple]
+        usa_state_select(:record, column.name, column.options[:priority], select_options, options)
+      end
+    end
+    
+    module SearchColumnHelpers
+      def active_scaffold_search_country(column, options)
+        active_scaffold_input_country(column, options.merge!(:selected => options.delete(:value)))       
+      end
+
+      def active_scaffold_search_usa_state(column, options)
+        active_scaffold_input_usa_state(column, options.merge!(:selected => options.delete(:value)))       
       end
     end
   end
-end
+end

data/vendor/plugins/active_scaffold/lib/active_scaffold/helpers/form_column_helpers.rb

@@ -4,37 +4,47 @@ module ActiveScaffold
     module FormColumnHelpers
       # This method decides which input to use for the given column.
       # It does not do any rendering. It only decides which method is responsible for rendering.
-      def active_scaffold_input_for(column, scope = nil)
-        options = active_scaffold_input_options(column, scope)
-
-        # first, check if the dev has created an override for this specific field
-        if override_form_field?(column)
-          send(override_form_field(column), @record, options[:name])
-
-        # second, check if the dev has specified a valid form_ui for this column
-        elsif column.form_ui and override_input?(column.form_ui)
-          send(override_input(column.form_ui), column, options)
-
-        # fallback: we get to make the decision
-        else
-          if 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}'"
-          elsif column.virtual?
-            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 override_input?(column.column.type)
-              send(override_input(column.column.type), column, options)
-            # final ultimate fallback: use rails' generic input method
-            else
-              # for textual fields we pass different options
-              text_types = [:text, :string, :integer, :float, :decimal]
-              options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
-              input(:record, column.name, options.merge(column.options))
+      def active_scaffold_input_for(column, scope = nil, options = {})
+        begin
+          options = active_scaffold_input_options(column, scope, options)
+          options = javascript_for_update_column(column, scope, options)
+          # first, check if the dev has created an override for this specific field
+          if override_form_field?(column)
+            send(override_form_field(column), @record, options)
+          # second, check if the dev has specified a valid form_ui for this column
+          elsif column.form_ui and override_input?(column.form_ui)
+            send(override_input(column.form_ui), column, options)
+          # fallback: we get to make the decision
+          else
+            if 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}'"
+            elsif column.virtual?
+              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 override_input?(column.column.type)
+                send(override_input(column.column.type), column, options)
+              # final ultimate fallback: use rails' generic input method
+              else
+                # for textual fields we pass different options
+                text_types = [:text, :string, :integer, :float, :decimal]
+                date_types = [:date, :datetime, :time]
+                options = active_scaffold_input_text_options(options) if text_types.include?(column.column.type)
+                options = active_scaffold_input_date_options(column, options) if date_types.include?(column.column.type)
+                if column.column.type == :string && options[:maxlength].blank?
+                  options[:maxlength] = column.column.limit
+                  options[:size] ||= ActionView::Helpers::InstanceTag::DEFAULT_FIELD_OPTIONS["size"]
+                end
+                options[:value] = format_number_value(@record.send(column.name), column.options) if column.column.number?
+                input(:record, column.name, options.merge(column.options))
+              end
             end
           end
+        rescue Exception => e
+          logger.error Time.now.to_s + "#{e.inspect} -- on the ActiveScaffold column = :#{column.name} in #{@controller.class}"
+          raise e
         end
       end
 
@@ -47,44 +57,77 @@ module ActiveScaffold
         options
       end
 
+      # the standard active scaffold options used for date, datetime and time inputs
+      def active_scaffold_input_date_options(column, options = {})
+        options[:include_blank] = true if column.column.null
+        options[:prefix] = options[:name].gsub("[#{column.name}]", '')
+        options
+      end
+
       # the standard active scaffold options used for class, name and scope
-      def active_scaffold_input_options(column, scope = nil)
+      def active_scaffold_input_options(column, scope = nil, options = {})
         name = scope ? "record#{scope}[#{column.name}]" : "record[#{column.name}]"
 
         # Fix for keeping unique IDs in subform
         id_control = "record_#{column.name}_#{[params[:eid], params[:id]].compact.join '_'}"
         id_control += scope.gsub(/(\[|\])/, '_').gsub('__', '_').gsub(/_$/, '') if scope
 
-        { :name => name, :class => "#{column.name}-input", :id => id_control}
+        { :name => name, :class => "#{column.name}-input", :id => id_control}.merge(options)
       end
- 
+
+      def javascript_for_update_column(column, scope, options)
+        if column.update_column
+          form_action = :create
+          form_action = :update if params[:action] == 'edit'
+          url_params = {
+            :action => 'render_field',
+            :id => params[:id],
+            :column => column.name,
+            :update_column => column.update_column,
+            :eid => params[:eid],
+            :scope => scope
+          }
+          url_params[:controller] = controller.class.active_scaffold_controller_for(@record.class).controller_path if scope
+          ajax_options = {:method => :get, 
+                          :url => url_for(url_params), :with => column.send_form_on_update_column ? "Form.serialize('#{element_form_id(:action => form_action)}')" : "'value=' + this.value",
+                          :after => "$('#{loading_indicator_id(:action => form_action, :id => params[:id])}').style.visibility = 'visible'; Form.disable('#{element_form_id(:action => form_action)}');",
+                          :complete => "$('#{loading_indicator_id(:action => form_action, :id => params[:id])}').style.visibility = 'hidden'; Form.enable('#{element_form_id(:action => form_action)}');"}
+          options[:onchange] = "#{remote_function(ajax_options)};#{options[:onchange]}"
+        end
+        options
+      end
+
       ##
       ## Form input methods
       ##
 
-      def active_scaffold_input_singular_association(column, options)
+      def active_scaffold_input_singular_association(column, html_options)
         associated = @record.send(column.association.name)
 
         select_options = options_for_association(column.association)
         select_options.unshift([ associated.to_label, associated.id ]) unless associated.nil? or select_options.find {|label, id| id == associated.id}
 
-        selected = associated.nil? ? nil : associated.id
-        method = column.association.macro == :belongs_to ? column.association.primary_key_name : column.name
-        options[:name] += '[id]'
-        select(:record, method, select_options.uniq, {:selected => selected, :include_blank => as_(:_select_)}, options)
+        method = column.name
+        #html_options[:name] += '[id]'
+        options = {:include_blank => as_(:_select_)}
+
+        html_options.update(column.options[:html_options] || {})
+        options.update(column.options)
+        options[:selected] = associated.id unless associated.nil?
+        select(:record, method, select_options.uniq, options, html_options)
       end
 
       def active_scaffold_input_plural_association(column, options)
         associated_options = @record.send(column.association.name).collect {|r| [r.to_label, r.id]}
         select_options = associated_options | options_for_association(column.association)
-        return as_(:no_options) if select_options.empty?
+        return content_tag(:span, as_(:no_options), :id => options[:id]) if select_options.empty?
 
         html = "<ul class=\"checkbox-list\" id=\"#{options[:id]}\">"
 
         associated_ids = associated_options.collect {|a| a[1]}
         select_options.each_with_index do |option, i|
           label, id = option
-          this_name = "#{options[:name]}[#{i}][id]"
+          this_name = "#{options[:name]}[]"
           this_id = "#{options[:id]}_#{i}_id"
           html << "<li>"
           html << check_box_tag(this_name, id, associated_ids.include?(id), :id => this_id)
@@ -96,47 +139,44 @@ module ActiveScaffold
 
         html << '</ul>'
         html << javascript_tag("new DraggableLists('#{options[:id]}')") if column.options[:draggable_lists]
-        html
+        html.html_safe
+      end
+
+      def active_scaffold_translated_option(column, text, value = nil)
+        value = text if value.nil?
+        [(text.is_a?(Symbol) ? column.active_record_class.human_attribute_name(text) : text), value.to_s]
       end
 
-      def active_scaffold_input_select(column, options)
+      def active_scaffold_translated_options(column)
+        column.options[:options].collect do |text, value|
+          active_scaffold_translated_option(column, text, value)
+        end
+      end
+
+      def active_scaffold_input_select(column, html_options)
         if column.singular_association?
-          active_scaffold_input_singular_association(column, options)
+          active_scaffold_input_singular_association(column, html_options)
         elsif column.plural_association?
-          active_scaffold_input_plural_association(column, options)
+          active_scaffold_input_plural_association(column, html_options)
         else
-          select(:record, column.name, column.options, { :selected => @record.send(column.name) }, options)
+          options = { :selected => @record.send(column.name).to_s }
+          options_for_select = active_scaffold_translated_options(column)
+          html_options.update(column.options[:html_options] || {})
+          options.update(column.options)
+          select(:record, column.name, options_for_select, options, html_options)
         end
       end
 
-      # only works for singular associations
-      # requires RecordSelect plugin to be installed and configured.
-      # ... maybe this should be provided in a bridge?
-      def active_scaffold_input_record_select(column, options)
-        unless column.association
-          raise ArgumentError, "record_select can only work against associations (and #{column.name} is not).  A common mistake is to specify the foreign key field (like :user_id), instead of the association (:user)."
+      def active_scaffold_input_radio(column, html_options)
+        html_options.update(column.options[:html_options] || {})
+        column.options[:options].inject('') do |html, (text, value)|
+          text, value = active_scaffold_translated_option(column, text, value)
+          html << content_tag(:label, radio_button(:record, column.name, value, html_options.merge(:id => html_options[:id] + '-' + value.to_s)) + text)
         end
-        remote_controller = active_scaffold_controller_for(column.association.klass).controller_path
-
-        # if the opposite association is a :belongs_to (in that case association in this class must be has_one or has_many)
-        # then only show records that have not been associated yet
-        if [:has_one, :has_many].include?(column.association.macro)
-          params.merge!({column.association.primary_key_name => ''})
-        end
-        
-        record_select_options = {:controller => remote_controller, :id => options[:id]}
-        record_select_options.merge!(active_scaffold_input_text_options)
-        record_select_options.merge!(column.options)
-
-        if column.singular_association?
-          record_select_field(options[:name], (@record.send(column.name) || column.association.klass.new), record_select_options)
-        elsif column.plural_association?
-          record_multi_select_field(options[:name], @record.send(column.name), record_select_options)
-        end   
       end
 
       def active_scaffold_input_checkbox(column, options)
-        check_box(:record, column.name, options)
+        check_box(:record, column.name, options.merge(column.options))
       end
 
       def active_scaffold_input_password(column, options)
@@ -145,9 +185,9 @@ module ActiveScaffold
       end
 
       def active_scaffold_input_textarea(column, options)
-        text_area(:record, column.name, options.merge(:cols => column.options[:cols], :rows => column.options[:rows]))
+        text_area(:record, column.name, options.merge(:cols => column.options[:cols], :rows => column.options[:rows], :size => column.options[:size]))
       end
-
+      
       def active_scaffold_input_virtual(column, options)
         options = active_scaffold_input_text_options(options)
         text_field :record, column.name, options.merge(column.options)
@@ -163,7 +203,7 @@ module ActiveScaffold
         select_options << [as_(:true), true]
         select_options << [as_(:false), false]
 
-        select_tag(options[:name], options_for_select(select_options, @record.send(column.name)))
+        select_tag(options[:name], options_for_select(select_options, @record.send(column.name)), options)
       end
 
       def onsubmit
@@ -174,32 +214,40 @@ module ActiveScaffold
       ##
 
       # add functionality for overriding subform partials from association class path
-      def override_subform_partial?(column)
-        path, partial_name = partial_pieces(override_subform_partial(column))
+      def override_subform_partial?(column, subform_partial)
+        path, partial_name = partial_pieces(override_subform_partial(column, subform_partial))
         template_exists?(File.join(path, "_#{partial_name}"))
       end
 
-      def override_subform_partial(column)
-        File.join(active_scaffold_controller_for(column.association.klass).controller_path, "subform") if column_renders_as(column) == :subform
+      def override_subform_partial(column, subform_partial)
+        File.join(active_scaffold_controller_for(column.association.klass).controller_path, subform_partial) if column_renders_as(column) == :subform
       end
 
       def override_form_field_partial?(column)
         path, partial_name = partial_pieces(override_form_field_partial(column))
-        template_exists?(File.join(path, "_#{partial_name}"))
+        template_exists?(File.join(path, "_#{partial_name}"), true)
       end
 
-      # the naming convention for overriding form fields with partials
+      # the naming convention for overriding form fields with helpers
       def override_form_field_partial(column)
-        "#{column.name}_form_column"
+        path = active_scaffold_controller_for(column.active_record_class).controller_path
+        File.join(path, "#{clean_column_name(column.name)}_form_column")
       end
 
-      def override_form_field?(column)
-        respond_to?(override_form_field(column))
+      def override_form_field(column)
+        method = override_form_field_name(column)
+        return method if respond_to?(method)
+        old_method = override_form_field_name(column, true)
+        if respond_to?(old_method)
+          ActiveSupport::Deprecation.warn("You are using an old naming schema for overrides, you should name the helper #{method} instead of #{old_method}")
+          old_method
+        end
       end
+      alias_method :override_form_field?, :override_form_field
 
       # the naming convention for overriding form fields with helpers
-      def override_form_field(column)
-        "#{column.name}_form_column"
+      def override_form_field_name(column, old = false)
+        "#{clean_class_name(column.active_record_class.name) + '_' unless old}#{clean_column_name(column.name)}_form_column"
       end
 
       def override_input?(form_ui)
@@ -224,10 +272,11 @@ module ActiveScaffold
       end
 
       def subform_partial_for_column(column)
-        if override_subform_partial?(column)
-          override_subform_partial(column)
+        subform_partial = "#{active_scaffold_config_for(column.association.klass).subform.layout}_subform"
+        if override_subform_partial?(column, subform_partial)
+          override_subform_partial(column, subform_partial)
         else
-          "horizontal_subform"
+          subform_partial
         end
       end
 
@@ -238,7 +287,7 @@ module ActiveScaffold
       def column_renders_as(column)
         if column.is_a? ActiveScaffold::DataStructures::ActionColumns
           return :subsection
-        elsif column.active_record_class.locking_column.to_s == column.name.to_s
+        elsif column.active_record_class.locking_column.to_s == column.name.to_s or column.form_ui == :hidden
           return :hidden
         elsif column.association.nil? or column.form_ui or !active_scaffold_config_for(column.association.klass).actions.include?(:subform)
           return :field
@@ -262,6 +311,28 @@ module ActiveScaffold
           "[#{column.name}]"
         end
       end
+
+      def active_scaffold_add_existing_input(options)
+        if controller.respond_to?(:record_select_config)
+          remote_controller = active_scaffold_controller_for(record_select_config.model).controller_path
+          options.merge!(:controller => remote_controller)
+          options.merge!(active_scaffold_input_text_options)
+          record_select_field(options[:name], @record, options)
+        else
+          column = active_scaffold_config_for(params[:parent_model]).columns[params[:parent_column]]
+          select_options = options_for_select(options_for_association(column.association)) unless column.through_association?
+          select_options ||= options_for_select(active_scaffold_config.model.find(:all).collect {|c| [h(c.to_label), c.id]})
+          select_tag 'associated_id', '<option value="">' + as_(:_select_) + '</option>' + select_options unless select_options.empty?
+        end
+      end
+
+      def active_scaffold_add_existing_label
+        if controller.respond_to?(:record_select_config)
+          record_select_config.model.human_name
+        else
+          active_scaffold_config.model.human_name
+        end
+      end
     end
   end
 end