six-updater-web 0.10.8 → 0.11.1

data/lib/vendor/plugins/in_place_editing/README

@@ -0,0 +1,14 @@
+InPlaceEditing
+==============
+
+Example:
+
+  # Controller
+  class BlogController < ApplicationController
+    in_place_edit_for :post, :title
+  end
+
+  # View
+  <%= in_place_editor_field :post, 'title' %>
+
+Copyright (c) 2007 David Heinemeier Hansson, released under the MIT license  

data/lib/vendor/plugins/in_place_editing/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test in_place_editing plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for in_place_editing plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'InPlaceEditing'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/vendor/plugins/in_place_editing/init.rb

@@ -0,0 +1,2 @@
+ActionController::Base.send :include, InPlaceEditing
+ActionController::Base.helper InPlaceMacrosHelper

data/lib/vendor/plugins/in_place_editing/lib/in_place_editing.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module InPlaceEditing
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Example:
+  #
+  #   # Controller
+  #   class BlogController < ApplicationController
+  #     in_place_edit_for :post, :title
+  #   end
+  #
+  #   # View
+  #   <%= in_place_editor_field :post, 'title' %>
+  #
+  module ClassMethods
+    def in_place_edit_for(object, attribute, options = {})
+      define_method("set_#{object}_#{attribute}") do
+        unless [:post, :put].include?(request.method) then
+          return render(:text => 'Method not allowed', :status => 405)
+        end
+        @item = object.to_s.camelize.constantize.find(params[:id])
+        @item.update_attribute(attribute, params[:value])
+        render :text => CGI::escapeHTML(@item.send(attribute).to_s)
+      end
+    end
+  end
+end

data/lib/vendor/plugins/in_place_editing/lib/in_place_macros_helper.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+module InPlaceMacrosHelper
+  # Makes an HTML element specified by the DOM ID +field_id+ become an in-place
+  # editor of a property.
+  #
+  # A form is automatically created and displayed when the user clicks the element,
+  # something like this:
+  #   <form id="myElement-in-place-edit-form" target="specified url">
+  #     <input name="value" text="The content of myElement"/>
+  #     <input type="submit" value="ok"/>
+  #     <a onclick="javascript to cancel the editing">cancel</a>
+  #   </form>
+  # 
+  # The form is serialized and sent to the server using an AJAX call, the action on
+  # the server should process the value and return the updated value in the body of
+  # the reponse. The element will automatically be updated with the changed value
+  # (as returned from the server).
+  # 
+  # Required +options+ are:
+  # <tt>:url</tt>::       Specifies the url where the updated value should
+  #                       be sent after the user presses "ok".
+  # 
+  # Addtional +options+ are:
+  # <tt>:rows</tt>::              Number of rows (more than 1 will use a TEXTAREA)
+  # <tt>:cols</tt>::              Number of characters the text input should span (works for both INPUT and TEXTAREA)
+  # <tt>:size</tt>::              Synonym for :cols when using a single line text input.
+  # <tt>:cancel_text</tt>::       The text on the cancel link. (default: "cancel")
+  # <tt>:save_text</tt>::         The text on the save link. (default: "ok")
+  # <tt>:loading_text</tt>::      The text to display while the data is being loaded from the server (default: "Loading...")
+  # <tt>:saving_text</tt>::       The text to display when submitting to the server (default: "Saving...")
+  # <tt>:external_control</tt>::  The id of an external control used to enter edit mode.
+  # <tt>:load_text_url</tt>::     URL where initial value of editor (content) is retrieved.
+  # <tt>:options</tt>::           Pass through options to the AJAX call (see prototype's Ajax.Updater)
+  # <tt>:with</tt>::              JavaScript snippet that should return what is to be sent
+  #                               in the AJAX call, +form+ is an implicit parameter
+  # <tt>:script</tt>::            Instructs the in-place editor to evaluate the remote JavaScript response (default: false)
+  # <tt>:click_to_edit_text</tt>::The text shown during mouseover the editable text (default: "Click to edit")
+  def in_place_editor(field_id, options = {})
+    function =  "new Ajax.InPlaceEditor("
+    function << "'#{field_id}', "
+    function << "'#{url_for(options[:url])}'"
+
+    js_options = {}
+
+    if protect_against_forgery?
+      options[:with] ||= "Form.serialize(form)"
+      options[:with] += " + '&authenticity_token=' + encodeURIComponent('#{form_authenticity_token}')"
+    end
+
+    js_options['cancelText'] = %('#{options[:cancel_text]}') if options[:cancel_text]
+    js_options['okText'] = %('#{options[:save_text]}') if options[:save_text]
+    js_options['loadingText'] = %('#{options[:loading_text]}') if options[:loading_text]
+    js_options['savingText'] = %('#{options[:saving_text]}') if options[:saving_text]
+    js_options['rows'] = options[:rows] if options[:rows]
+    js_options['cols'] = options[:cols] if options[:cols]
+    js_options['size'] = options[:size] if options[:size]
+    js_options['externalControl'] = "'#{options[:external_control]}'" if options[:external_control]
+    js_options['loadTextURL'] = "'#{url_for(options[:load_text_url])}'" if options[:load_text_url]        
+    js_options['ajaxOptions'] = options[:options] if options[:options]
+    js_options['htmlResponse'] = !options[:script] if options[:script]
+    js_options['callback']   = "function(form) { return #{options[:with]} }" if options[:with]
+    js_options['clickToEditText'] = %('#{options[:click_to_edit_text]}') if options[:click_to_edit_text]
+    js_options['textBetweenControls'] = %('#{options[:text_between_controls]}') if options[:text_between_controls]
+    function << (', ' + options_for_javascript(js_options)) unless js_options.empty?
+    
+    function << ')'
+
+    javascript_tag(function).force_encoding("utf-8") # TODO: Only on Ruby 1.9!
+  end
+  
+  # Renders the value of the specified object and method with in-place editing capabilities.
+  def in_place_editor_field(object, method, tag_options = {}, in_place_editor_options = {})
+    instance_tag = ::ActionView::Helpers::InstanceTag.new(object, method, self)
+    tag_options = {:tag => "span",
+                   :id => "#{object}_#{method}_#{instance_tag.object.id}_in_place_editor",
+                   :class => "in_place_editor_field"}.merge!(tag_options)
+    in_place_editor_options[:url] = in_place_editor_options[:url] || url_for({ :action => "set_#{object}_#{method}", :id => instance_tag.object.id })
+    tag = content_tag(tag_options.delete(:tag), h(instance_tag.value(instance_tag.object)),tag_options)
+    return (tag + in_place_editor(tag_options[:id], in_place_editor_options)).force_encoding("utf-8")  # TODO: Only on Ruby 1.9!
+  end
+end

data/lib/vendor/plugins/in_place_editing/test/in_place_editing_test.rb

@@ -0,0 +1,89 @@
+require File.expand_path(File.dirname(__FILE__) + "/test_helper")
+
+class InPlaceEditingTest < Test::Unit::TestCase
+  include InPlaceEditing
+  include InPlaceMacrosHelper
+  
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::FormHelper
+  include ActionView::Helpers::CaptureHelper
+  
+  def setup
+    @controller = Class.new do
+      def url_for(options)
+        url =  "http://www.example.com/"
+        url << options[:action].to_s if options and options[:action]
+        url
+      end
+    end
+    @controller = @controller.new
+    @protect_against_forgery = false
+  end
+
+  def protect_against_forgery?
+    @protect_against_forgery
+  end
+
+  def test_in_place_editor_external_control
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {externalControl:'blah'})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :external_control => 'blah'})
+  end
+  
+  def test_in_place_editor_size
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {size:4})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :size => 4})
+  end
+  
+  def test_in_place_editor_cols_no_rows
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {cols:4})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :cols => 4})
+  end
+  
+  def test_in_place_editor_cols_with_rows
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {cols:40, rows:5})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :rows => 5, :cols => 40})
+  end
+
+  def test_inplace_editor_loading_text
+      assert_dom_equal %(<script type=\"text/javascript\">\n//<![CDATA[\nnew Ajax.InPlaceEditor('some_input', 'http://www.example.com/inplace_edit', {loadingText:'Why are we waiting?'})\n//]]>\n</script>),
+        in_place_editor('some_input', {:url => {:action => 'inplace_edit'}, :loading_text => 'Why are we waiting?'})
+  end
+  
+  def test_in_place_editor_url
+    assert_match "Ajax.InPlaceEditor('id-goes-here', 'http://www.example.com/action_to_set_value')",
+    in_place_editor( 'id-goes-here', :url => { :action => "action_to_set_value" })    
+  end
+  
+  def test_in_place_editor_load_text_url
+    assert_match "Ajax.InPlaceEditor('id-goes-here', 'http://www.example.com/action_to_set_value', {loadTextURL:'http://www.example.com/action_to_get_value'})",
+    in_place_editor( 'id-goes-here', 
+      :url => { :action => "action_to_set_value" }, 
+      :load_text_url => { :action => "action_to_get_value" })
+  end
+  
+  def test_in_place_editor_html_response
+    assert_match "Ajax.InPlaceEditor('id-goes-here', 'http://www.example.com/action_to_set_value', {htmlResponse:false})",
+    in_place_editor( 'id-goes-here', 
+      :url => { :action => "action_to_set_value" }, 
+      :script => true )
+  end
+  
+  def form_authenticity_token
+    "authenticity token"
+  end
+
+  def test_in_place_editor_with_forgery_protection
+    @protect_against_forgery = true
+    assert_match "Ajax.InPlaceEditor('id-goes-here', 'http://www.example.com/action_to_set_value', {callback:function(form) { return Form.serialize(form) + '&authenticity_token=' + encodeURIComponent('authenticity token') }})",
+    in_place_editor( 'id-goes-here', :url => { :action => "action_to_set_value" })
+  end
+
+  def test_in_place_editor_text_between_controls
+    assert_match "Ajax.InPlaceEditor('id-goes-here', 'http://www.example.com/action_to_set_value', {textBetweenControls:'or'})",
+    in_place_editor( 'id-goes-here',
+      :url => { :action => "action_to_set_value" },
+      :text_between_controls => "or" )
+  end
+end

data/lib/vendor/plugins/in_place_editing/test/test_helper.rb

@@ -0,0 +1,8 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit'
+require 'rubygems'
+require 'action_controller'
+require 'action_controller/assertions'
+require 'in_place_editing'
+require 'in_place_macros_helper'

data/lib/vendor/plugins/recordselect/CHANGELOG

@@ -0,0 +1,25 @@
+1.0
+* record_select_field always searches on the latest string
+* R.S. dialog closes on mousedown instead of click (because sometimes clicks are intercepted)
+* R.S. layers over <select> boxes in IE 6
+* record_select_field now opens R.S. even when the field loads with focus
+* new :onchange option for record_select_field, to observe selection events
+
+1.0rc1
+* helpers complain if the controller they're configured for doesn't use recordselect
+* when using keyboard navigation, hitting "enter" to select a record no longer submits the form
+* if text field is empty when dialog is closed, then recordselect will empty the hidden field as well (lets you deselect)
+* support for multiple selections (record_multi_select_helper)
+* param-based search conditions are smarter - can search numeric fields as well
+* using record_select_conditions_from_controller instead of conditions_for_collection. also added a new record_select_includes override method.
+* helpers now accept a :class option
+* fixed bug with url escaping when helpers were configured with multiple parameters
+* new :label configuration option. it's a proc - the default one calls record.to_label (for backwards compatibility).
+* cleaned up merge_conditions to use activerecord's sanitize_sql.
+* div.record-select-container now has a high z-index so it will by default be visible above other absolutely positioned elements.
+
+0.9
+stuff
+
+0.1
+stuff

data/lib/vendor/plugins/recordselect/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Lance Ivy
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/vendor/plugins/recordselect/README

@@ -0,0 +1,11 @@
+RecordSelect
+============
+
+(c) 2007 - Lance Ivy
+
+RecordSelect is a Rails widget to help you pick one record out of many. I designed it as a more usable and performant alternative to generating a massive dropdown list. It relies on AJAX for the cooler uses (all the provided view helpers rely on JavaScript?) but can also function in a pure-http fashion (although multi-select support is provided in a pure-JavaScript implementation).
+
+Please see the ActionView::Helpers::RecordSelectHelpers for the most common API. More documentation (and HOWTOs) can be found online at http://code.google.com/p/recordselect, and a demo application is available at http://recordselect.googlecode.com/svn/demo.
+
+= DEPENDENCIES
+This depends on the excellent Paginator gem by Bruce Williams. This simple gem is available at paginator.rubyforge.org.

data/lib/vendor/plugins/recordselect/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the recordselect plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the recordselect plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Recordselect'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('assets/**/*.js')
+end

data/lib/vendor/plugins/recordselect/app/helpers/record_select_helper.rb

@@ -0,0 +1,187 @@
+module RecordSelectHelper
+  # Print this from your layout to include everything necessary for RecordSelect to work.
+  # Well, not everything. You need Prototype too.
+  def record_select_includes
+    includes = ''
+    includes << stylesheet_link_tag('record_select/record_select')
+    includes << javascript_include_tag('record_select/record_select')
+    includes
+  end
+
+  # Adds a link on the page that toggles a RecordSelect widget from the given controller.
+  #
+  # *Options*
+  # +onselect+::  JavaScript code to handle selections client-side. This code has access to two variables: id, label. If the code returns false, the dialog will *not* close automatically.
+  # +params+::    Extra URL parameters. If any parameter is a column name, the parameter will be used as a search term to filter the result set.
+  def link_to_record_select(name, controller, options = {})
+    options[:params] ||= {}
+    options[:params].merge!(:controller => controller, :action => :browse)
+    options[:onselect] = "function(id, label) {#{options[:onselect]}}" if options[:onselect]
+    options[:html] ||= {}
+    options[:html][:id] ||= "rs_#{rand(9999)}"
+
+    assert_controller_responds(options[:params][:controller])
+
+    html = link_to_function(name, '', options[:html])
+    html << javascript_tag("new RecordSelect.Dialog(#{options[:html][:id].to_json}, #{url_for(options[:params].merge(:escape => false)).to_json}, {onselect: #{options[:onselect] || ''}})")
+
+    return html
+  end
+
+  # Adds a RecordSelect-based form field. The field submits the record's id using a hidden input.
+  #
+  # *Arguments*
+  # +name+:: the input name that will be used to submit the selected record's id.
+  # +current+:: the currently selected object. provide a new record if there're none currently selected and you have not passed the optional :controller argument.
+  #
+  # *Options*
+  # +controller+::  The controller configured to provide the result set. Optional if you have standard resource controllers (e.g. UsersController for the User model), in which case the controller will be inferred from the class of +current+ (the second argument)
+  # +params+::      A hash of extra URL parameters
+  # +id+::          The id to use for the input. Defaults based on the input's name.
+  # +onchange+::    A JavaScript function that will be called whenever something new is selected. It should accept the new id as the first argument, and the new label as the second argument. For example, you could set onchange to be "function(id, label) {alert(id);}", or you could create a JavaScript function somewhere else and set onchange to be "my_function" (without the parantheses!).
+  def record_select_field(name, current, options = {})
+    options[:controller] ||= current.class.to_s.pluralize.underscore
+    options[:params] ||= {}
+    options[:id] ||= name.gsub(/[\[\]]/, '_')
+
+    controller = assert_controller_responds(options[:controller])
+
+    id = label = ''
+    if current and not current.new_record?
+      id = current.id
+      label = label_for_field(current, controller)
+    end
+
+    url = url_for({:action => :browse, :controller => options[:controller], :escape => false}.merge(options[:params]))
+
+    html = text_field_tag(name, nil, :autocomplete => 'off', :id => options[:id], :class => options[:class], :onfocus => "this.focused=true", :onblur => "this.focused=false")
+    html << javascript_tag("new RecordSelect.Single(#{options[:id].to_json}, #{url.to_json}, {id: #{id.to_json}, label: #{label.to_json}, onchange: #{options[:onchange] || ''.to_json}});")
+
+    return html
+  end
+
+  # Assists with the creation of an observer for the :onchange option of the record_select_field method.
+  # Currently only supports building an Ajax.Request based on the id of the selected record.
+  #
+  # options[:url] should be a hash with all the necessary options *except* :id. that parameter
+  # will be provided based on the selected record.
+  #
+  # Question: if selecting users, what's more likely?
+  #   /users/5/categories
+  #   /categories?user_id=5
+  def record_select_observer(options = {})
+    fn = ""
+    fn << "function(id, value) {"
+    fn <<   "var url = #{url_for(options[:url].merge(:id => ":id:")).to_json}.replace(/:id:/, id);"
+    fn <<   "new Ajax.Request(url);"
+    fn << "}"
+  end
+
+  # Adds a RecordSelect-based form field for multiple selections. The values submit using a list of hidden inputs.
+  #
+  # *Arguments*
+  # +name+:: the input name that will be used to submit the selected records' ids. empty brackets will be appended to the name.
+  # +current+:: pass a collection of existing associated records
+  #
+  # *Options*
+  # +controller+::  The controller configured to provide the result set.
+  # +params+::      A hash of extra URL parameters
+  # +id+::          The id to use for the input. Defaults based on the input's name.
+  def record_multi_select_field(name, current, options = {})
+    options[:controller] ||= current.first.class.to_s.pluralize.underscore
+    options[:params] ||= {}
+    options[:id] ||= name.gsub(/[\[\]]/, '_')
+
+    controller = assert_controller_responds(options[:controller])
+
+    current = current.inject([]) { |memo, record| memo.push({:id => record.id, :label => label_for_field(record, controller)}) }
+
+    url = url_for({:action => :browse, :controller => options[:controller], :escape => false}.merge(options[:params]))
+
+    html = text_field_tag("#{name}[]", nil, :autocomplete => 'off', :id => options[:id], :class => options[:class], :onfocus => "this.focused=true", :onblur => "this.focused=false")
+    html << content_tag('ul', '', :class => 'record-select-list');
+    html << javascript_tag("new RecordSelect.Multiple(#{options[:id].to_json}, #{url.to_json}, {current: #{current.to_json}});")
+
+    return html
+  end
+
+  # A helper to render RecordSelect partials
+  def render_record_select(options = {}) #:nodoc:
+    controller.send(:render_record_select, options) do |options|
+      render options
+    end
+  end
+
+  # Provides view access to the RecordSelect configuration
+  def record_select_config #:nodoc:
+    controller.send :record_select_config
+  end
+
+  # The id of the RecordSelect widget for the given controller.
+  def record_select_id(controller = nil) #:nodoc:
+    controller ||= params[:controller]
+    "record-select-#{controller.gsub('/', '_')}"
+  end
+
+  def record_select_search_id(controller = nil) #:nodoc:
+    "#{record_select_id(controller)}-search"
+  end
+
+  private
+  # render the record using the renderer and add a link to select the record
+  def render_record_in_list(record, controller_path)
+    text = render_record_from_config(record)
+    if record_select_config.link?
+      url_params = {:controller => controller_path, :action => :select, :id => record.id, :escape => false}
+      link_to_remote text, {
+          :url => url_params,
+          :method => :post,
+          :before => 'Element.toggleClassName(this, "selected")',
+          :condition => "RecordSelect.notify(this)"
+        }, :href => url_params
+    else
+      text
+    end
+  end
+
+
+  # uses renderer (defaults to record_select_config.label) to determine how the given record renders.
+  def render_record_from_config(record, renderer = record_select_config.label)
+    case renderer
+    when Symbol, String
+      # return full-html from the named partial
+      render :partial => renderer.to_s, :locals => {:record => record}
+
+    when Proc
+      # return an html-cleaned descriptive string
+      h renderer.call(record)
+    end
+  end
+
+  # uses the result of render_record_from_config to snag an appropriate record label
+  # to display in a field.
+  #
+  # if given a controller, searches for a partial in its views path
+  def label_for_field(record, controller = self.controller)
+    renderer = controller.record_select_config.label
+    case renderer
+    when Symbol, String
+      # find the <label> element and grab its innerHTML
+      description = render_record_from_config(record, File.join(controller.controller_path, renderer.to_s))
+      description.match(/<label[^>]*>(.*)<\/label>/)[1]
+
+    when Proc
+      # just return the string
+      render_record_from_config(record, renderer)
+    end
+  end
+
+  def assert_controller_responds(controller_name)
+    controller_name = "#{controller_name.camelize}Controller"
+    controller = controller_name.constantize
+    unless controller.uses_record_select?
+      raise "#{controller_name} has not been configured to use RecordSelect."
+    end
+    controller
+  end
+end