scaffolding_extensions 1.0.0

data/lib/scaffolding_extensions/jquery_helper.rb

@@ -0,0 +1,58 @@
+module ScaffoldingExtensions
+  # Helper methods that require the JQuery Javascript library to work
+  module JQueryHelper
+    JS_CHAR_FILTER = {'<'=>'\u003C', '>'=>'\u003E', '"'=>'\\"', "\n"=>'\n'}
+    
+    private
+      # Javascript for adding an element to the top of the list of associated records,
+      # and setting the autocomplete text box value to blank (if using autocompleting),
+      # or removing the item from the select box and showing the blank record instead
+      # (if not using autocompleting).
+      def scaffold_add_habtm_element
+        content = "$('##{@records_list}').prepend(\"#{scaffold_javascript_character_filter(scaffold_habtm_association_line_item(@klass, @association, @record, @associated_record))}\");\n"
+        if @auto_complete
+          content << "$('##{@element_id}').val('');\n"
+        else
+          content << "$('##{@element_id}_#{@associated_record.scaffold_id}').remove();\n"
+          content << "$('##{@element_id}').selectedIndex = 0;\n"
+        end
+        content
+      end
+      
+      # A form tag with an onsubmit attribute that submits the form to the given url via Ajax
+      def scaffold_form_remote_tag(url, options)
+        u = scaffold_url(url, options)
+        "<form method='post' action='#{u}' onsubmit=\"$.post('#{u}', $(this).serialize(), function(data, textStatus){eval(data);}); return false;\">\n#{scaffold_token_tag}\n"
+      end
+      
+      # Javascript that takes the given id as the text box to autocomplete for, 
+      # submitting the autocomplete request to scaffold_auto_complete_for_#{model_name}
+      # (with the association if one is given), using the get method, and displaying values
+      # in #{id}_scaffold_auto_complete.
+      def scaffold_javascript_autocompleter(id, model_name, association)
+        scaffold_javascript_tag("$('##{id}').autocomplete({ajax:'#{scaffold_url("scaffold_auto_complete_for_#{model_name}")}'#{", association:'#{association}'" if association}});")
+      end
+      
+      # Filters some html entities and replaces them with their javascript equivalents
+      # suitable for use inside a javascript quoted string.
+      def scaffold_javascript_character_filter(string)
+        string.gsub(/[<>"\n]/){|x| JS_CHAR_FILTER[x]}
+      end
+      
+      # Div with link inside that requests the associations html for the @scaffold_object
+      # via Ajax and replaces the link with the html returned by the request
+      def scaffold_load_associations_with_ajax_link
+        soid = @scaffold_object.scaffold_id
+        divid = "scaffold_ajax_content_#{soid}"
+        "<div id='#{divid}'><a href='#{scaffold_url("edit#{@scaffold_suffix}", :id=>soid, :associations=>:show)}' onclick=\"$('##{divid}').load('#{scaffold_url("associations#{@scaffold_suffix}", :id=>soid)}'); return false;\">Modify Associations</a></div>"
+      end
+      
+      # Javascript that removes @remove_element_id from the page and inserts
+      # an option into the appropriate select box (unless @auto_complete).
+      def scaffold_remove_existing_habtm_element
+        content = "$('##{@remove_element_id}').remove();\n"
+        content << "$('##{@select_id}').append(\"\\u003Coption value='#{@select_value}' id='#{@select_id}_#{@select_value}'\\u003E#{@select_text}\\u003C/option\\u003E\");\n" unless @auto_complete
+        content
+      end
+  end
+end

data/lib/scaffolding_extensions/meta_controller.rb

@@ -0,0 +1,337 @@
+module ScaffoldingExtensions
+  # Contains class methods shared across controllers
+  module MetaController
+    attr_accessor :scaffolded_methods, :scaffolded_nonidempotent_methods, :scaffolded_auto_complete_associations
+    
+    # The location of the scaffold templates
+    def scaffold_template_dir
+      @scaffold_template_dir ||= TEMPLATE_DIR
+    end
+    
+    private 
+      # Creates a series of administrative forms for a given model klass. All actions
+      # defined have the suffix "_#{klass.scaffold_name}".
+      #
+      # Takes the following options:
+      #
+      # - :except: symbol or array of method symbols not to define
+      # - :only: symbol or array of method symbols to define instead of the default
+      #
+      # The following method symbols are used to control the methods that get
+      # added by the scaffold function:
+      #
+      # - :browse: Browse all model objects, similar to a search for every record.
+      # - :delete: Shows a select box with all objects (or an autocompleting text box), allowing the user to chose
+      #   an object to delete
+      # - :edit: Shows a select box with all objects (or an autocompleting text box), allowing the user to chose
+      #   an object to edit.  When one is selected, shows a form for changing the fields.
+      #   Also shows associations specified in the model's scaffold_associations,
+      #   allowing you easy access to manage associated models and objects.
+      # - :manage: Page that has links to all the other methods.
+      # - :new: Form for creating new objects
+      # - :merge: Brings up two fields (usually select fields), allowing the user to
+      #   pick one to merge into the other.  Merging takes all objects associated with
+      #   the object to be merged and replaces those associations with associations to
+      #   the object is it being merged into, and then it deletes the object being merged.
+      # - :search: Simple search form. The results page has links to show, edit,
+      #   or destroy each object.
+      # - :show: Shows a select box with all objects (or an autocompleting text box), allowing the user to chose
+      #   an object, which then shows the attribute name and value for scaffolded fields.
+      #   Also shows associations specified in the model's scaffold_associations.
+      def scaffold(klass, options = {})
+        scaffold_setup 
+        singular_name = klass.scaffold_name
+        singular_human_name = klass.scaffold_human_name
+        plural_name = singular_name.pluralize
+        plural_human_name = singular_human_name.pluralize
+        suffix = "_#{singular_name}"
+        add_methods = options[:only] ? scaffold_normalize_options(options[:only]) : scaffold_default_methods
+        add_methods -= scaffold_normalize_options(options[:except])
+        scaffold_options = {:singular_name=>singular_name, :plural_name=>plural_name, :singular_human_name=>singular_human_name, :plural_human_name=>plural_human_name, :class=>klass, :suffix=>suffix, :singular_lc_human_name=>singular_human_name.downcase, :plural_lc_human_name=>plural_human_name.downcase}
+
+        scaffold_auto_complete_for(klass) if klass.scaffold_use_auto_complete
+        klass.scaffold_auto_complete_associations.each{|association| scaffold_auto_complete_for(klass, association)}
+        
+        if add_methods.include?(:manage)
+          scaffold_define_method("manage#{suffix}") do
+            scaffold_render_template(:manage, scaffold_options)
+          end
+        end
+        
+        if add_methods.include?(:show) or add_methods.include?(:destroy) or add_methods.include?(:edit)
+          scaffold_define_method("list#{suffix}") do
+            @scaffold_objects ||= klass.scaffold_find_objects(@scaffold_action, :session=>scaffold_session) unless klass.scaffold_use_auto_complete
+            scaffold_render_template(:list, scaffold_options)
+          end
+        end
+        
+        if add_methods.include?(:show)
+          scaffold_define_method("show#{suffix}") do
+            if scaffold_request_id
+              @scaffold_object ||= klass.scaffold_find_object(:show, scaffold_request_id, :session=>scaffold_session)
+              @scaffold_associations_readonly = true
+              scaffold_render_template(:show, scaffold_options)
+            else
+              @scaffold_action = :show
+              send("list#{suffix}")
+            end
+          end
+        end
+        
+        if add_methods.include?(:delete)
+          scaffold_define_method("delete#{suffix}") do
+            @scaffold_action = :destroy
+            send("list#{suffix}")
+          end
+          
+          scaffold_define_nonidempotent_method("destroy#{suffix}") do
+            @scaffold_object ||= klass.scaffold_find_object(:delete, scaffold_request_id, :session=>scaffold_session)
+            klass.scaffold_destroy(@scaffold_object)
+            scaffold_redirect('delete', suffix, "#{singular_human_name} was successfully destroyed")
+          end
+        end
+        
+        if add_methods.include?(:edit)
+          klass.scaffold_habtm_associations.each{|association| scaffold_habtm(klass, association)}
+
+          scaffold_define_method("edit#{suffix}") do
+            if scaffold_request_id
+              @scaffold_show_associations = true if scaffold_request_param(:associations) == 'show'
+              @scaffold_object ||= klass.scaffold_find_object(:edit, scaffold_request_id, :session=>scaffold_session)
+              scaffold_render_template(:edit, scaffold_options)
+            else
+              @scaffold_action = :edit
+              send("list#{suffix}")
+            end
+          end
+          
+          scaffold_define_nonidempotent_method("update#{suffix}") do
+            @scaffold_object ||= klass.scaffold_find_object(:edit, scaffold_request_id, :session=>scaffold_session)
+            klass.scaffold_update_attributes(@scaffold_object, scaffold_request_param(singular_name))
+            if klass.scaffold_save(:edit, @scaffold_object)
+              scaffold_redirect(:edit, suffix, "#{singular_human_name} was successfully updated")
+            else
+              scaffold_render_template(:edit, scaffold_options)
+            end
+          end
+          
+          if klass.scaffold_load_associations_with_ajax
+            scaffold_define_method("associations#{suffix}") do
+              @scaffold_object ||= klass.scaffold_find_object(:edit, scaffold_request_id, :session=>scaffold_session)
+              scaffold_render_template(:associations, scaffold_options, :inline=>"<%= scaffold_habtm_ajax_associations %>\n<%= scaffold_association_links %>\n")
+            end
+          end
+        end
+        
+        if add_methods.include?(:new)
+          scaffold_define_method("new#{suffix}") do
+            @scaffold_object ||= klass.scaffold_new_object(scaffold_request_param(singular_name), :session=>scaffold_session)
+            scaffold_render_template(:new, scaffold_options)
+          end
+          
+          scaffold_define_nonidempotent_method("create#{suffix}") do
+            @scaffold_object ||= klass.scaffold_new_object(scaffold_request_param(singular_name), :session=>scaffold_session)
+            if klass.scaffold_save(:new, @scaffold_object)
+              scaffold_redirect(:new, suffix, "#{singular_human_name} was successfully created")
+            else
+              scaffold_render_template(:new, scaffold_options)
+            end
+          end
+        end
+        
+        if add_methods.include?(:search)
+          scaffold_define_method("search#{suffix}") do
+            @scaffold_object ||= klass.scaffold_search_object
+            scaffold_render_template(:search, scaffold_options)
+          end
+          
+          scaffold_define_method("results#{suffix}") do
+            page = scaffold_request_param(:page).to_i > 1 ? scaffold_request_param(:page).to_i : 1
+            page -= 1 if scaffold_request_param(:page_previous)
+            page += 1 if scaffold_request_param(:page_next)
+            @scaffold_search_results_form_params, @scaffold_objects = klass.scaffold_search(:model=>scaffold_request_param(singular_name), :notnull=>scaffold_force_array(scaffold_request_param(:notnull)), :null=>scaffold_force_array(scaffold_request_param(:null)), :page=>page, :session=>scaffold_session)
+            @scaffold_listtable_type = :search
+            scaffold_render_template(:listtable, scaffold_options)
+          end
+        end
+      
+        if add_methods.include?(:merge)
+          scaffold_define_method("merge#{suffix}") do
+            @scaffold_objects ||= klass.scaffold_find_objects(:merge, :session=>scaffold_session) unless klass.scaffold_use_auto_complete
+            scaffold_render_template(:merge, scaffold_options)
+          end
+          
+          scaffold_define_nonidempotent_method("merge_update#{suffix}") do
+            notice = if klass.scaffold_merge_records(scaffold_request_param(:from), scaffold_request_param(:to), :session=>scaffold_session)
+              "#{plural_human_name} were successfully merged"
+            else
+              "Error merging #{plural_human_name.downcase}"
+            end
+            scaffold_redirect(:merge, suffix, notice)
+          end
+        end
+        
+        if add_methods.include?(:browse)
+          scaffold_define_method("browse#{suffix}") do
+            @page ||= scaffold_request_param(:page).to_i > 1 ? scaffold_request_param(:page).to_i : 1
+            @next_page, @scaffold_objects = klass.scaffold_browse_find_objects(:session=>scaffold_session, :page=>@page)
+            @scaffold_listtable_type = :browse
+            scaffold_render_template(:listtable, scaffold_options)
+          end
+        end
+      end
+      
+      # Scaffolds all models with one command
+      #
+      # Takes the following options:
+      # - :except: model class or array of model classes not to scaffold
+      # - :only: only scaffold model classes included in this array
+      # - model class: hash of options for the scaffold method for this model
+      def scaffold_all_models(options={})
+        scaffold_setup
+        links = scaffold_all_models_parse_options(options).collect do |model, options|
+          scaffold(model, options)
+          ["manage_#{model.scaffold_name}", model.scaffold_human_name]
+        end
+        scaffold_define_method('index') do
+          @links = links
+          scaffold_render_template('index')
+        end
+      end
+      
+      # Parse the arguments for scaffold_all_models.  Seperated so that it can
+      # also be used in testing.
+      def scaffold_all_models_parse_options(options={})
+        except = scaffold_normalize_options(options[:except])
+        only = scaffold_normalize_options(options[:only]) if options[:only]
+        models = (only || ScaffoldingExtensions.all_models).reject{|model| except.include?(model)}
+        models.collect{|model| [model, options[model] || {}]}
+      end
+      
+      # Create action for returning results from the scaffold autocompleter
+      # for the given model.  If an association is given, allows autocompleting for
+      # objects in an association.
+      def scaffold_auto_complete_for(klass, association=nil)
+        meth = "scaffold_auto_complete_for_#{klass.scaffold_name}"
+        (self.scaffolded_auto_complete_associations[klass] ||= Set.new).add(association.to_s)
+        allowed_associations = scaffolded_auto_complete_associations[klass]
+        unless instance_methods.include?(meth)
+          scaffold_define_method(meth) do
+            association = scaffold_request_param(:association).to_s
+            if scaffold_request_param(:association) && !allowed_associations.include?(association)
+              scaffold_method_not_allowed
+            else
+              @items = klass.scaffold_auto_complete_find(scaffold_request_id.to_s, :association=>(association.to_sym if scaffold_request_param(:association)), :session=>scaffold_session)
+              scaffold_render_template(meth, {}, :inline => "<%= scaffold_auto_complete_result(@items) %>")
+            end
+          end
+        end
+      end
+      
+      # The methods that should be added by the scaffolding function by default
+      def scaffold_default_methods
+        @scaffold_default_methods ||= DEFAULT_METHODS
+      end
+      
+      # Define method and add method name to scaffolded_methods
+      def scaffold_define_method(name, &block)
+        scaffolded_methods.add(name)
+        define_method(name, &block)
+      end
+      
+      # Define method and add method name to scaffolded_methods and
+      # scaffolded_nonidempotent_methods
+      def scaffold_define_nonidempotent_method(name, &block)
+        scaffolded_nonidempotent_methods.add(name)
+        scaffold_define_method(name, &block)
+      end
+      
+      # Scaffolds a habtm association for a class and an association using two select boxes, or
+      # a select box for removing associations and an autocompleting text box for
+      # adding associations.    
+      def scaffold_habtm(klass, association)
+        scaffold_setup
+        sn = klass.scaffold_name
+        scaffold_auto_complete_for(klass, association) if auto_complete = klass.scaffold_association_use_auto_complete(association)
+        
+        if klass.scaffold_habtm_with_ajax
+          suffix = "_#{sn}"
+          records_list = "#{sn}_associated_records_list"
+          element_id = "#{sn}_#{association}_id"
+          add_meth = "add_#{association}_to_#{sn}"
+          scaffold_define_nonidempotent_method(add_meth) do
+            @record = klass.scaffold_find_object(:habtm, scaffold_request_id, :session=>scaffold_session)
+            @associated_record = klass.scaffold_add_associated_objects(association, @record, {:session=>scaffold_session}, scaffold_request_param(element_id))
+            if scaffold_xhr?
+              @klass = klass
+              @association = association
+              @records_list = records_list
+              @auto_complete = auto_complete
+              @element_id = element_id
+              @scaffold_javascript = true
+              scaffold_render_template(add_meth, {}, :inline=>'<%= scaffold_add_habtm_element %>')
+            else
+              scaffold_redirect_to(scaffold_url("edit#{suffix}", :id=>@record.scaffold_id))
+            end
+          end
+          
+          remove_meth = "remove_#{association}_from_#{sn}"
+          scaffold_define_nonidempotent_method(remove_meth) do
+            @record = klass.scaffold_find_object(:habtm, scaffold_request_id, :session=>scaffold_session)
+            @associated_record = klass.scaffold_remove_associated_objects(association, @record, {:session=>scaffold_session}, scaffold_request_param(element_id))
+            @auto_complete = auto_complete
+            if scaffold_xhr?
+              @remove_element_id = "#{sn}_#{@record.scaffold_id}_#{association}_#{@associated_record.scaffold_id}"
+              @select_id = element_id
+              @select_value = @associated_record.scaffold_id
+              @select_text = @associated_record.scaffold_name
+              @scaffold_javascript = true
+              scaffold_render_template(remove_meth, {}, :inline=>'<%= scaffold_remove_existing_habtm_element %>')
+            else
+              scaffold_redirect_to(scaffold_url("edit#{suffix}", :id=>@record.scaffold_id))
+            end
+          end
+        else
+          suffix = "_#{sn}_#{association}"
+          # aplch_name = association plural lower case human name
+          scaffold_options={:aplch_name=>association.to_s.humanize.downcase, :singular_name=>sn, :association=>association, :class=>klass, :suffix=>suffix}
+          # aslch_name = association singular lower case human name
+          scaffold_options[:aslhc_name] = scaffold_options[:aplch_name].singularize
+          
+          scaffold_define_method("edit#{suffix}") do
+            @scaffold_object = klass.scaffold_find_object(:habtm, scaffold_request_id, :session=>scaffold_session, :association=>association)
+            @items_to_remove = klass.scaffold_associated_objects(association, @scaffold_object, :session=>scaffold_session)
+            @items_to_add = klass.scaffold_unassociated_objects(association, @scaffold_object, :session=>scaffold_session) unless klass.scaffold_association_use_auto_complete(association)
+            scaffold_render_template(:habtm, scaffold_options)
+          end
+          
+          scaffold_define_nonidempotent_method("update#{suffix}") do
+            @scaffold_object = klass.scaffold_find_object(:habtm, scaffold_request_id, :session=>scaffold_session, :association=>association)
+            klass.scaffold_add_associated_objects(association, @scaffold_object, {:session=>scaffold_session}, *scaffold_select_ids(scaffold_request_param(:add)))
+            klass.scaffold_remove_associated_objects(association, @scaffold_object, {:session=>scaffold_session}, *scaffold_select_ids(scaffold_request_param(:remove)))
+            scaffold_redirect(:edit, suffix, "Updated #{@scaffold_object.scaffold_name}'s #{scaffold_options[:aplch_name]} successfully", @scaffold_object.scaffold_id)
+          end
+        end
+      end
+      
+      # Normalizes options to the scaffold command, allowing submission of symbols or arrays of symbols
+      def scaffold_normalize_options(options)
+        case options
+          when Array then options
+          when nil then []
+          else [options]
+        end
+      end
+      
+      # Setup resources used by both scaffold and scaffold_habtm.  Adds shared data structures that
+      # should only be initialized once.
+      def scaffold_setup
+        return if @scaffolding_shared_resources_are_setup
+        self.scaffolded_methods ||= Set.new
+        self.scaffolded_nonidempotent_methods ||= Set.new
+        self.scaffolded_auto_complete_associations ||= {}
+        scaffold_setup_helper
+        @scaffolding_shared_resources_are_setup = true
+      end
+  end
+end

data/lib/scaffolding_extensions/meta_model.rb

@@ -0,0 +1,571 @@
+# Class methods shared by all models
+#
+# Many class methods can be overridden for particular use cases by setting other methods
+# or instance variables.  For example, scaffold_fields is a method that takes an action,
+# such as :new.  scaffold_fields(:new) will first check if scaffold_new_fields is a method, and
+# will call it if so.  If not, it will check if @scaffold_new_fields is defined, and use it if
+# so.  If not, will take the default course of action.
+# 
+# The first argument to the overridable method is used to search for the override method
+# or instance variable.  If a override method is used, the remaining
+# arguments to the overridable method will be passed to it.  Otherwise, the default method will
+# be used.
+#
+# For example, scaffold_find_object(action, id, options) is an overridable method.
+# That means if :delete is the action, it will first look for scaffold_delete_find_object, and if it
+# exists it will call scaffold_delete_find_object(id, options).
+#
+# If a method can be overridden by an instance variable, it should have only one argument.
+#
+# The methods that are overridable by other methods are (without the "scaffold_" prefix): 
+# add_associated_objects, associated_objects, association_find_object, association_find_objects,
+# find_object, find_objects, new_associated_object_values, remove_associated_objects, save,
+# unassociated_objects, and filter_attributes.
+#
+# The methods that are overridable by other methods or instance variables are (again, without the
+# "scaffold_" prefix): associated_human_name, association_use_auto_complete, fields, include,
+# select_order, attributes, include_association, and select_order_association.
+#
+# Most methods that find objects check options[:session][scaffold_session_value] as a
+# security check if scaffold_session_value is set.
+#
+# There are some methods that are so similar that they are dynamically defined using
+# define_method.  They are:
+#
+# - scaffold_association_list_class: The html class attribute of the association list
+# - scaffold_habtm_with_ajax: Whether to use Ajax when scaffolding habtm associations for this model
+# - scaffold_load_associations_with_ajax: Whether to use Ajax when loading associations on the edit page
+# - scaffold_browse_records_per_page: The number of records to show on each page when using the browse scaffold
+# - scaffold_convert_text_to_string: Whether to use input of type text instead of a text area for columns of type :text
+# - scaffold_search_results_limit: The maximum number of results to show on the scaffolded search results page
+#
+# Each of these methods can be set with an instance variable.  If the instance variable is
+# not set, it will use the default value from SCAFFOLD_OPTIONS.
+module ScaffoldingExtensions::MetaModel
+  # Sets the default options for all models, which can be overriden by class instance
+  # variables (iv):
+  # - :text_to_string: If true, by default, use input type text instead of textarea 
+  #   for fields of type text (iv: @scaffold_convert_text_to_string)
+  # - :table_classes: Set the default table classes for different scaffolded HTML tables
+  #   (iv: @scaffold_table_classes)
+  # - :column_types: Override the default column type for a given attribute 
+  #   (iv: @scaffold_column_types)
+  # - :column_options: Override the default column options for a given attribute
+  #   (iv: @scaffold_column_options_hash)
+  # - :column_names: Override the visible names of columns for each attribute
+  #   (iv: @scaffold_column_names)
+  # - :association_list_class: Override the html class for the association list in the edit view
+  #   (iv: @scaffold_association_list_class)
+  # - :browse_limit: The default number of records per page to show in the
+  #   browse scaffold. If nil, the search results will be displayed on one page instead
+  #   of being paginated (iv: @scaffold_browse_records_per_page)
+  # - :search_limit: The default limit on scaffolded search results.  If nil,
+  #   the search results will be displayed on one page instead of being paginated
+  #   (iv: @scaffold_search_results_limit)
+  # - :habtm_ajax: Whether or not to use Ajax (instead of a separate page) for 
+  #   modifying habtm associations (iv: @scaffold_habtm_with_ajax)
+  # - :load_associations_ajax - Whether or not to use Ajax to load the display of
+  #   associations on the edit page, useful if the default display is too slow
+  #   (iv: @scaffold_load_associations_with_ajax)
+  # - :auto_complete: Hash containing the default options to use for the scaffold
+  #   autocompleter (iv: @scaffold_auto_complete_options)
+  SCAFFOLD_OPTIONS = {:text_to_string=>false, 
+    :table_classes=>{:form=>'formtable', :list=>'sortable', :show=>'sortable'},
+    :column_types=>{},
+    :column_options=>{},
+    :association_list_class=>''.freeze,
+    :column_names=>{},
+    :browse_limit=>10,
+    :search_limit=>10,
+    :habtm_ajax=>false,
+    :load_associations_ajax=>false,
+    :auto_complete=>{:enable=>false, :sql_name=>'LOWER(name)', :format_string=>:substring, 
+      :search_operator=>'LIKE', :results_limit=>10, :phrase_modifier=>:downcase},
+  }
+  
+  {:association_list_class=>:scaffold_association_list_class,
+  :habtm_ajax=>:scaffold_habtm_with_ajax,
+  :load_associations_ajax=>:scaffold_load_associations_with_ajax,
+  :browse_limit=>:scaffold_browse_records_per_page,
+  :text_to_string=>:scaffold_convert_text_to_string,
+  :search_limit=>:scaffold_search_results_limit}.each do |default, iv|
+    ivs = "@#{iv}"
+    define_method(iv) do
+      if instance_variable_defined?(ivs)
+        instance_variable_get(ivs)
+      else
+        instance_variable_set(ivs, SCAFFOLD_OPTIONS[default])
+      end
+    end
+  end
+
+  # Control access to objects of this model via a session value.  For example
+  # if set to :user_id, would only show objects with the same user_id as
+  # session[:user_id], and would not allow access to any objects that didn't
+  # have a matching user_id.
+  attr_reader :scaffold_session_value
+  
+  # Override the typical table-based form display by overriding these wrappers.
+  # Should return a proc that takes an html label and
+  # widget and returns an html fragment.
+  attr_reader :scaffold_field_wrapper
+  
+  # Override the typical table-based form display by overriding these wrappers.
+  # Should return a proc that takes rows returned by
+  # scaffold_field_wrapper and returns an html fragment.
+  attr_reader :scaffold_form_wrapper
+
+  # Add the objects specified by associated_object_ids to the given object
+  # using the given association.  If the object to be associated with the given object is
+  # already associated with it, skip it (don't try to associate it multiple times).
+  # Returns the associated object (if only one id was given), or an array of objects
+  # (if multiple ids were given).
+  def scaffold_add_associated_objects(association, object, options, *associated_object_ids)
+    unless associated_object_ids.empty?
+      scaffold_transaction do
+        associated_objects = associated_object_ids.collect do |associated_object_id|
+          associated_object = scaffold_association_find_object(association, associated_object_id.to_i, :session=>options[:session])
+          scaffold_add_associated_object(association, object, associated_object)
+          associated_object
+        end
+        associated_object_ids.length == 1 ? associated_objects.first : associated_objects
+      end
+    end
+  end
+
+  # Return the human name for the given association, defaulting to humanizing the
+  # association name
+  def scaffold_associated_human_name(association)
+    association.to_s.humanize
+  end
+
+  # The scaffold_name of the associated class.  Not overridable, as that allows for the
+  # possibility of broken links.
+  def scaffold_associated_name(association)
+    scaffold_associated_class(association).scaffold_name
+  end
+
+  # All objects that are currently associated with the given object. This method does not
+  # check that the returned associated objects meet the associated class's scaffold_session_value
+  # constraint, as it is assumed that all objects currently assocated with the given object
+  # have already met the criteria.  If that is not the case, you should override this method.
+  def scaffold_associated_objects(association, object, options)
+    object.send(association)
+  end
+
+  # Finds a given object in the associated class that has the matching id.
+  def scaffold_association_find_object(association, id, options)
+    scaffold_associated_class(association).scaffold_find_object(:associated, id, options)
+  end
+  
+  # Find all objects of the associated class. Does not use any conditions of the association
+  # (they are can't be used reliably, since they require an object to interpolate them), so
+  # if there are special conditions on the association, you'll want to override this method.
+  def scaffold_association_find_objects(association, options)
+    klass = scaffold_associated_class(association)
+    klass.scaffold_get_objects(:order=>scaffold_select_order_association(association), :include=>scaffold_include_association(association), :conditions=>klass.scaffold_session_conditions(options[:session]))
+  end
+
+  # Whether to use autocompleting for linked associations. Defaults to whether the
+  # associated class uses auto completing.
+  def scaffold_association_use_auto_complete(association)
+    scaffold_associated_class(association).scaffold_use_auto_complete
+  end
+
+  # Defaults to associations specified by scaffold fields that are autocompleting. Can be set with an instance variable.
+  def scaffold_auto_complete_associations
+    @scaffold_auto_complete_associations ||= scaffold_fields(:edit).reject{|field| !(scaffold_association(field) && scaffold_association_use_auto_complete(field))}
+  end
+  
+  # Return all records that match the given phrase (usually a substring of
+  # the most important column).  If options[:association] is present, delegate to the associated
+  # class's scaffold_auto_complete_find.
+  #
+  # Allows method override (options.delete(:association))
+  def scaffold_auto_complete_find(phrase, options = {})
+    session = options.delete(:session)
+    if association = options.delete(:association)
+      if meth = scaffold_method_override(:auto_complete_find, association, phrase, options)
+        meth.call
+      else
+        scaffold_associated_class(association).scaffold_auto_complete_find(phrase, :session=>session)
+      end
+    else
+      find_options = { :limit => scaffold_auto_complete_results_limit,
+          :conditions => [scaffold_auto_complete_conditions(phrase), scaffold_session_conditions(session)],
+          :order => scaffold_select_order(:auto_complete),
+          :include => scaffold_include(:auto_complete)}.merge(options)
+      scaffold_get_objects(find_options)
+    end
+  end
+  
+  # Separate method for browsing objects, as it also needs to return whether or not there is another
+  # page of objects.  Returns [another_page, objects], where another_page is true or false.
+  def scaffold_browse_find_objects(options)
+    get_options = {:order=>scaffold_select_order(:browse), :include=>scaffold_include(:browse), :conditions=>scaffold_session_conditions(options[:session])}
+    if limit = scaffold_browse_records_per_page
+      get_options[:offset] = (options[:page].to_i-1) * limit
+      get_options[:limit] = limit = limit + 1
+    end
+    objects = scaffold_get_objects(get_options)
+    if limit && objects.length == limit
+      objects.pop
+      [true, objects]
+    else
+      [false, objects]
+    end 
+  end 
+
+  # Returns the human name for a given attribute.  Can be set via the instance variable
+  # @scaffold_column_names, a hash with the column name as a symbol key and the human name
+  # string as the value.
+  def scaffold_column_name(column_name)
+    @scaffold_column_names ||= SCAFFOLD_OPTIONS[:column_names].dup
+    @scaffold_column_names[column_name] ||= if scaffold_association(column_name)
+      scaffold_associated_human_name(column_name)
+    else
+      column_name.to_s.humanize
+    end 
+  end
+
+  # Returns any special options for a given attribute.  Can be set via the instance variable
+  # @scaffold_column_options_hash, a hash with the column name as a symbol key and the html
+  # options hash as the value.
+  def scaffold_column_options(column_name)
+    @scaffold_column_options_hash ||= SCAFFOLD_OPTIONS[:column_options].dup
+    @scaffold_column_options_hash[column_name] || {}
+  end
+
+  # Returns the column type for the given scaffolded column name.  Can be set via the instance
+  # variable @scaffold_column_types, a hash with the column name as a symbol key and the html
+  # type symbol as a value.  Associations have the :association type, and other types are looked
+  # up via columns_hash[column_name].type.  If no type is provided, :string is used by default.
+  def scaffold_column_type(column_name)
+    @scaffold_column_types ||= SCAFFOLD_OPTIONS[:column_types].dup
+    if @scaffold_column_types[column_name]
+      @scaffold_column_types[column_name]
+    elsif scaffold_association(column_name)
+      :association
+    elsif type = scaffold_table_column_type(column_name)
+      (scaffold_convert_text_to_string && (type == :text)) ? :string : type
+    else
+      :string
+    end
+  end
+
+  # Returns the foreign key for the field if it is an association, or the field
+  # as a string if it is not.
+  def scaffold_field_id(field)
+    if reflection = scaffold_association(field)
+      scaffold_foreign_key(reflection)
+    else
+      field.to_s
+    end
+  end
+
+  # Find the object of this model given by the id
+  def scaffold_find_object(action, id, options)
+    object = scaffold_get_object(id)
+    raise scaffold_error_raised unless scaffold_session_value_matches?(object, options[:session])
+    object
+  end
+  
+  # Find all objects of this model
+  def scaffold_find_objects(action, options)
+    scaffold_get_objects(:order=>scaffold_select_order(action), :include=>scaffold_include(action), :conditions=>scaffold_session_conditions(options[:session]))
+  end
+
+  # Array of symbols for all habtm associations in this model's scaffold_associations.
+  # Can be set with an instance variable.
+  def scaffold_habtm_associations
+    @scaffold_habtm_associations ||= scaffold_associations.reject{|association| scaffold_association_type(association) != :edit}
+  end
+
+  # The human name string for this model. Can be set with an instance variable.
+  def scaffold_human_name
+    @scaffold_human_name ||= scaffold_name.humanize
+  end
+
+  # The name string to use in urls, defaults to name.underscore.  Can be set with an 
+  # instance variable.
+  def scaffold_name
+    @scaffold_name ||= name.underscore
+  end
+
+  # Merges the record with id from into the record with id to.  Updates all 
+  # associated records for the record with id from to be assocatiated with
+  # the record with id to instead, and then deletes the record with id from.
+  #
+  # Returns false if the ids given are the same or the scaffold_session_value
+  # criteria is not met.
+  def scaffold_merge_records(from, to, options)
+    from, to = from.to_i, to.to_i
+    return false if from == to
+    from_object = scaffold_get_object(from)
+    return false unless scaffold_session_value_matches?(from_object, options[:session])
+    to_object = scaffold_get_object(to)
+    return false unless scaffold_session_value_matches?(to_object, options[:session])
+    scaffold_transaction do
+      scaffold_all_associations.each{|reflection| scaffold_reflection_merge(reflection, from, to)}
+      scaffold_destroy(from_object)
+    end
+    true
+  end
+
+  # Creates a new object, setting the attributes if given.
+  def scaffold_new_object(attributes, options)
+    object = new(scaffold_filter_attributes(:new, attributes || {}))
+    object.send("#{scaffold_session_value}=", options[:session][scaffold_session_value]) if scaffold_session_value
+    object
+  end
+
+  # Removes associated objects with the given ids from the given object's association.
+  # Returns the associated object (if only one id was given), or an array of objects
+  # (if multiple ids were given).
+  def scaffold_remove_associated_objects(association, object, options, *associated_object_ids)
+    unless associated_object_ids.empty?
+      scaffold_transaction do
+        associated_objects = associated_object_ids.collect do |associated_object_id|
+          associated_object = scaffold_association_find_object(association, associated_object_id.to_i, :session=>options[:session])
+          scaffold_remove_associated_object(association, object, associated_object)
+          associated_object
+        end
+        associated_object_ids.length == 1 ? associated_objects.first : associated_objects
+      end
+    end
+  end
+  
+  # Searches for objects that meet the criteria specified by options:
+  # - :null: fields that must be must be NULL
+  # - :notnull: matching fields must be NOT NULL
+  # - :model: hash with field name strings as keys and strings as values.
+  #   uses the value for each field to search.  Strings are searched based on
+  #   substring, other values have to be an exact match.
+  # - :page: To determine which offset to use
+  #
+  # Returns [form_params, objects], where form_params are a list of parameters
+  # for the results form (for going to the next/previous page), and objects are
+  # all of the objects that matched.
+  def scaffold_search(options)
+    conditions = []
+    search_model = options[:model] || {}
+    object = scaffold_search_object(search_model)
+    null = options[:null]
+    notnull = options[:notnull]
+    form_params= {:model=>{}, :null=>[], :notnull=>[], :page=>options[:page]}
+    
+    limit, offset = nil, nil
+    if scaffold_search_pagination_enabled?
+      limit = scaffold_search_results_limit + 1
+      offset = options[:page] > 1 ? (limit-1)*(options[:page] - 1) : nil
+    end
+    
+    if search_model
+      scaffold_attributes(:search).each do |field|
+        fsym = field
+        field = field.to_s
+        next if (null && null.include?(field)) || \
+            (notnull && notnull.include?(field)) || \
+            search_model[field].nil? || search_model[field].empty?
+        case scaffold_column_type(fsym)
+          when :string, :text
+            conditions << scaffold_substring_condition(field, object.send(field))
+          else
+            conditions << scaffold_equal_condition(field, object.send(field))
+          end
+        form_params[:model][field] = search_model[field] if scaffold_search_pagination_enabled?
+      end
+    end
+    
+    scaffold_attributes(:search).each do |field|
+      field = field.to_s
+      if null && null.include?(field)
+        conditions << scaffold_null_condition(field)
+        form_params[:null] << field if scaffold_search_pagination_enabled?
+      end
+      if notnull && notnull.include?(field)
+        conditions << scaffold_notnull_condition(field)
+        form_params[:notnull] << field if scaffold_search_pagination_enabled?
+      end
+    end
+    
+    conditions << scaffold_session_conditions(options[:session])
+
+    objects = scaffold_get_objects(:conditions=>conditions, :include=>scaffold_include(:search), :order=>scaffold_select_order(:search), :limit=>limit, :offset=>offset)
+    if scaffold_search_pagination_enabled? && objects.length == scaffold_search_results_limit+1
+      form_params[:next_page] = true
+      objects.pop
+    end
+    [form_params, objects]
+  end
+
+  # List of human visible names and field name symbols to use for NULL/NOT NULL fields on the scaffolded search page.
+  # Can be set with an instance variable.
+  def scaffold_search_null_options
+    @scaffold_search_null_options ||= scaffold_attributes(:search).reject{|f| scaffold_table_column_type(f).nil?}.collect{|f| [scaffold_column_name(f), f]}
+  end
+  
+  # Returns a completely blank object suitable for searching, updated with the given attributes.
+  def scaffold_search_object(attributes = {})
+    object = new
+    scaffold_attributes(:search).each{|field| object.send("#{field}=", nil)}
+    scaffold_set_attributes(object, attributes)
+    object
+  end
+  
+  # The SQL ORDER BY fragment string.  Can be set with an instance variable.
+  def scaffold_select_order(action = :default)
+    @scaffold_select_order
+  end
+  
+  # The conditions array to use if scaffold_session_value is set, nil otherwise
+  def scaffold_session_conditions(session)
+    ["#{scaffold_table_name}.#{scaffold_session_value} = ?", session[scaffold_session_value]] if scaffold_session_value
+  end
+
+  # True if the given object meets the scaffold_session_value criteria
+  def scaffold_session_value_matches?(object, session)
+    !scaffold_session_value || object.send(scaffold_session_value) == session[scaffold_session_value]
+  end
+
+  # Whether to show associations links for the given association.  Generally true unless 
+  # it is an :has_and_belongs_to_many association and scaffold_habtm_with_ajax is true.
+  def scaffold_show_association_links?(association)
+    !(scaffold_habtm_with_ajax && scaffold_association_type(association) == :edit)
+  end
+
+  # Returns the scaffolded table class for a given scaffold type. Can be set with
+  # the instance variable @scaffold_table_classes, a hash with the type as the symbol key
+  # and the value as the html class string.
+  def scaffold_table_class(type)
+    @scaffold_table_classes ||= SCAFFOLD_OPTIONS[:table_classes].dup
+    @scaffold_table_classes[type]
+  end
+  
+  # Run the block inside a database transaction
+  def scaffold_transaction(&block)
+    transaction(&block)
+  end
+  
+  # Returns all objects of the associated class not currently associated with this object.
+  def scaffold_unassociated_objects(association, object, options)
+    scaffold_associated_class(association).scaffold_get_objects(:conditions=>[scaffold_unassociated_condition(association, object), scaffold_session_conditions(options[:session])], :order=>scaffold_select_order_association(association), :include=>scaffold_include_association(association))
+  end
+  
+  # Updates attributes for the given action, but does not save the record.
+  def scaffold_update_attributes(object, attributes)
+    scaffold_set_attributes(object, scaffold_filter_attributes(:edit, attributes))
+  end
+
+  # Whether this class should use an autocompleting text box instead of a select
+  # box for choosing items.  Can be set with an instance variable.
+  def scaffold_use_auto_complete
+    @scaffold_use_auto_complete ||= scaffold_auto_complete_options[:enable]
+  end
+
+  private
+    # scaffold_fields with associations replaced by foreign key fields
+    def scaffold_attributes(action = :default)
+      instance_variable_set("@scaffold_#{action}_attributes", scaffold_fields(action).collect{|field| scaffold_field_id(field).to_sym})
+    end
+    
+    # The conditions to use for the scaffolded autocomplete find.
+    def scaffold_auto_complete_conditions(phrase)
+      [scaffold_auto_complete_conditions_phrase, (scaffold_auto_complete_search_format_string % phrase.send(scaffold_auto_complete_phrase_modifier))]
+    end
+
+    # The conditions phrase (the sql code with ? place holders) used in the
+    # scaffolded autocomplete find.
+    def scaffold_auto_complete_conditions_phrase
+      scaffold_auto_complete_options[:conditions_phrase] ||= "#{scaffold_auto_complete_name_sql} #{scaffold_auto_complete_search_operator} ?"
+    end
+
+    # Search operator for matching scaffold_auto_complete_name_sql to format_string % phrase,
+    # usally 'LIKE', but might be 'ILIKE' on some databases.
+    def scaffold_auto_complete_search_operator
+      scaffold_auto_complete_options[:search_operator]
+    end
+
+    # SQL fragment (usually column name) that is used when scaffold autocompleting is turned on.
+    def scaffold_auto_complete_name_sql
+      scaffold_auto_complete_options[:sql_name]
+    end
+
+    # If the auto complete options have been setup, return them.  Otherwise,
+    # create the auto complete options using the defaults and the existing
+    # class instance variable.  Can be set as an instance variable.
+    def scaffold_auto_complete_options
+      return @scaffold_auto_complete_options if @scaffold_auto_complete_options && @scaffold_auto_complete_options[:setup]
+      @scaffold_auto_complete_options = @scaffold_auto_complete_options.nil? ? {} : {:enable=>true}.merge(@scaffold_auto_complete_options)
+      @scaffold_auto_complete_options = SCAFFOLD_OPTIONS[:auto_complete].merge(@scaffold_auto_complete_options)
+      @scaffold_auto_complete_options[:setup] = true
+      @scaffold_auto_complete_options
+    end
+    
+    # A symbol for a string method to send to the submitted phrase.  Usually
+    # :downcase to preform a case insensitive search, but may be :to_s for
+    # a case sensitive search.
+    def scaffold_auto_complete_phrase_modifier
+      scaffold_auto_complete_options[:phrase_modifier]
+    end
+
+    # The number of results to return for the scaffolded autocomplete text box.
+    def scaffold_auto_complete_results_limit
+      scaffold_auto_complete_options[:results_limit]
+    end
+    
+    # Format string used with the phrase to choose the type of search.  Can be
+    # a user defined format string or one of these special symbols:
+    # - :substring - Phase matches any substring of scaffold_auto_complete_name_sql
+    # - :starting - Phrase matches the start of scaffold_auto_complete_name_sql
+    # - :ending - Phrase matches the end of scaffold_auto_complete_name_sql
+    # - :exact - Phrase matches scaffold_auto_complete_name_sql exactly
+    def scaffold_auto_complete_search_format_string
+      {:substring=>'%%%s%%', :starting=>'%s%%', :ending=>'%%%s', :exact=>'%s'}[scaffold_auto_complete_options[:format_string]] || scaffold_auto_complete_options[:format_string]
+    end
+    
+    # Condition to ensure field equals value
+    def scaffold_equal_condition(field, value)
+      ["#{scaffold_table_name}.#{field} = ?", "%#{value}%"]
+    end
+
+    # Filters the provided attributes to just the ones given by scaffold_attributes for
+    # the given action.
+    def scaffold_filter_attributes(action, attributes)
+      allowed_attributes = scaffold_attributes(action).collect{|x| x.to_s}
+      attributes.reject{|k,v| !allowed_attributes.include?(k.to_s.split('(')[0])}
+    end
+    
+    # Condition to ensure field is not NULL
+    def scaffold_notnull_condition(field)
+      ["#{scaffold_table_name}.#{field} IS NOT NULL"]
+    end
+    
+    # Condition to ensure field is NULL
+    def scaffold_null_condition(field)
+      ["#{scaffold_table_name}.#{field} IS NULL"]
+    end
+
+    # If search pagination is enabled (by default it is if 
+    # scaffold_search_results_limit is not nil)
+    def scaffold_search_pagination_enabled?
+      !scaffold_search_results_limit.nil?
+    end
+    
+    # The SQL ORDER BY fragment string when ordering the association.
+    # Defaults to the scaffold_select_order for the associated class.
+    def scaffold_select_order_association(association)
+      scaffold_associated_class(association).scaffold_select_order(:association)
+    end
+    
+    # Condition to ensure value is a substring of field
+    def scaffold_substring_condition(field, value)
+      ["#{scaffold_table_name}.#{field} #{scaffold_auto_complete_search_operator} ?", "%#{value}%"]
+    end
+    
+    # Condition to ensure that objects from the associated class are not currently associated with object
+    def scaffold_unassociated_condition(association, object)
+      klass, left_key, right_key, join_table = scaffold_habtm_reflection_options(association)
+      ["#{klass.scaffold_table_name}.#{klass.scaffold_primary_key} NOT IN (SELECT #{join_table}.#{right_key} FROM #{join_table} WHERE #{join_table}.#{left_key} = ?)", object.scaffold_id]
+    end
+end