actionpack 1.11.2 → 1.12.0

data/lib/action_view/helpers/form_tag_helper.rb

@@ -15,16 +15,11 @@ module ActionView
       # Options:
       # * <tt>:multipart</tt> - If set to true, the enctype is set to "multipart/form-data".
       # * <tt>:method</tt> - The method to use when submitting the form, usually either "get" or "post".
-      def form_tag(url_for_options = {}, options = {}, *parameters_for_url)
+      def form_tag(url_for_options = {}, options = {}, *parameters_for_url, &proc)
         html_options = { "method" => "post" }.merge(options.stringify_keys)
-
-        if html_options["multipart"]
-          html_options["enctype"] = "multipart/form-data"
-          html_options.delete("multipart")
-        end
-
+        html_options["enctype"] = "multipart/form-data" if html_options.delete("multipart")
         html_options["action"] = url_for(url_for_options, *parameters_for_url)
-        tag("form", html_options, true)
+        tag :form, html_options, true
       end
 
       alias_method :start_form_tag, :form_tag
@@ -47,7 +42,7 @@ module ActionView
       # Options:
       # * <tt>:multiple</tt> - If set to true the selection will allow multiple choices.
       def select_tag(name, option_tags = nil, options = {})
-        content_tag("select", option_tags, { "name" => name, "id" => name }.update(options.stringify_keys))
+        content_tag :select, option_tags, { "name" => name, "id" => name }.update(options.stringify_keys)
       end
 
       # Creates a standard text field.
@@ -59,7 +54,7 @@ module ActionView
       # 
       # A hash of standard HTML options for the tag.
       def text_field_tag(name, value = nil, options = {})
-        tag("input", { "type" => "text", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys))
+        tag :input, { "type" => "text", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys)
       end
 
       # Creates a hidden field.
@@ -97,39 +92,46 @@ module ActionView
       #     # Outputs <textarea name="body" id="body" cols="25" rows="10"></textarea>
       #     <%= text_area_tag "body", nil, :size => "25x10" %>
       def text_area_tag(name, content = nil, options = {})
-        options = options.stringify_keys
-        if options["size"]
-          options["cols"], options["rows"] = options["size"].split("x")
-          options.delete("size")
+        options.stringify_keys!
+
+        if size = options.delete("size")
+          options["cols"], options["rows"] = size.split("x")
         end
 
-        content_tag("textarea", content, { "name" => name, "id" => name }.update(options.stringify_keys))
+        content_tag :textarea, content, { "name" => name, "id" => name }.update(options.stringify_keys)
       end
 
       # Creates a check box.
       def check_box_tag(name, value = "1", checked = false, options = {})
         html_options = { "type" => "checkbox", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys)
         html_options["checked"] = "checked" if checked
-        tag("input", html_options)
+        tag :input, html_options
       end
 
       # Creates a radio button.
       def radio_button_tag(name, value, checked = false, options = {})
         html_options = { "type" => "radio", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys)
         html_options["checked"] = "checked" if checked
-        tag("input", html_options)
+        tag :input, html_options
       end
 
-      # Creates a submit button with the text <tt>value</tt> as the caption.
+      # Creates a submit button with the text <tt>value</tt> as the caption. If options contains a pair with the key of "disable_with",
+      # then the value will be used to rename a disabled version of the submit button.
       def submit_tag(value = "Save changes", options = {})
-        tag("input", { "type" => "submit", "name" => "commit", "value" => value }.update(options.stringify_keys))
+        options.stringify_keys!
+        
+        if disable_with = options.delete("disable_with")
+          options["onclick"] = "this.disabled=true;this.value='#{disable_with}';this.form.submit();#{options["onclick"]}"
+        end
+          
+        tag :input, { "type" => "submit", "name" => "commit", "value" => value }.update(options.stringify_keys)
       end
       
       # Displays an image which when clicked will submit the form.
       #
       # <tt>source</tt> is passed to AssetTagHelper#image_path
       def image_submit_tag(source, options = {})
-        tag("input", { "type" => "image", "src" => image_path(source) }.update(options.stringify_keys))
+        tag :input, { "type" => "image", "src" => image_path(source) }.update(options.stringify_keys)
       end
     end
   end

data/lib/action_view/helpers/java_script_macros_helper.rb

@@ -12,11 +12,11 @@ module ActionView
       #
       # 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>
+      #   <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
@@ -29,12 +29,17 @@ module ActionView
       # 
       # 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 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)
       def in_place_editor(field_id, options = {})
         function =  "new Ajax.InPlaceEditor("
         function << "'#{field_id}', "
@@ -43,9 +48,14 @@ module ActionView
         js_options = {}
         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['rows'] = options[:rows] if options[:rows]
-        js_options['externalControl'] = options[:external_control] if options[:external_control]
+        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['evalScripts'] = options[:script] if options[:script]
         js_options['callback']   = "function(form) { return #{options[:with]} }" if options[:with]
         function << (', ' + options_for_javascript(js_options)) unless js_options.empty?
         
@@ -72,8 +82,12 @@ module ActionView
       # or nothing if no entries should be displayed for autocompletion.
       #
       # You'll probably want to turn the browser's built-in autocompletion off,
-      # su be sure to include a autocomplete="off" attribute with your text
+      # so be sure to include a autocomplete="off" attribute with your text
       # input field.
+      #
+      # The autocompleter object is assigned to a Javascript variable named <tt>field_id</tt>_auto_completer.
+      # This object is useful if you for example want to trigger the auto-complete suggestions through
+      # other means than user input (for that specific case, call the <tt>activate</tt> method on that object). 
       # 
       # Required +options+ are:
       # <tt>:url</tt>::       URL to call for autocompletion results
@@ -105,8 +119,11 @@ module ActionView
       #                       innerHTML is replaced.
       # <tt>:on_show</tt>::   Like on_hide, only now the expression is called
       #                       then the div is shown.
+      # <tt>:select</tt>::    Pick the class of the element from which the value for 
+      #                       insertion should be extracted. If this is not specified,
+      #                       the entire element is used.
       def auto_complete_field(field_id, options = {})
-        function =  "new Ajax.Autocompleter("
+        function =  "var #{field_id}_auto_completer = new Ajax.Autocompleter("
         function << "'#{field_id}', "
         function << "'" + (options[:update] || "#{field_id}_auto_complete") + "', "
         function << "'#{url_for(options[:url])}'"
@@ -115,9 +132,12 @@ module ActionView
         js_options[:tokens] = array_or_string_for_javascript(options[:tokens]) if options[:tokens]
         js_options[:callback]   = "function(element, value) { return #{options[:with]} }" if options[:with]
         js_options[:indicator]  = "'#{options[:indicator]}'" if options[:indicator]
-        {:on_show => :onShow, :on_hide => :onHide, :min_chars => :min_chars}.each do |k,v|
+        js_options[:select]     = "'#{options[:select]}'" if options[:select]
+
+        { :on_show => :onShow, :on_hide => :onHide, :min_chars => :minChars }.each do |k,v|
           js_options[v] = options[k] if options[k]
         end
+
         function << (', ' + options_for_javascript(js_options) + ')')
 
         javascript_tag(function)

data/lib/action_view/helpers/javascript_helper.rb

@@ -2,295 +2,80 @@ require File.dirname(__FILE__) + '/tag_helper'
 
 module ActionView
   module Helpers
-    # Provides a set of helpers for calling JavaScript functions and, most importantly, to call remote methods using what has 
-    # been labelled AJAX[http://www.adaptivepath.com/publications/essays/archives/000385.php]. This means that you can call 
-    # actions in your controllers without reloading the page, but still update certain parts of it using injections into the 
-    # DOM. The common use case is having a form that adds a new element to a list without reloading the page.
+    # Provides functionality for working with JavaScript in your views.
+    # 
+    # == Ajax, controls and visual effects
+    # 
+    # * For information on using Ajax, see 
+    #   ActionView::Helpers::PrototypeHelper.
+    # * For information on using controls and visual effects, see
+    #   ActionView::Helpers::ScriptaculousHelper.
     #
-    # To be able to use the JavaScript helpers, you must include the Prototype JavaScript Framework and for some functions
-    # script.aculo.us (which both come with Rails) on your pages. Choose one of these options:
+    # == Including the JavaScript libraries into your pages
     #
-    # * Use <tt><%= javascript_include_tag :defaults %></tt> in the HEAD section of your page (recommended):
-    #   The function will return references to the JavaScript files created by the +rails+ command in your
-    #   <tt>public/javascripts</tt> directory. Using it is recommended as the browser can then cache the libraries
-    #   instead of fetching all the functions anew on every request.
-    # * Use <tt><%= javascript_include_tag 'prototype' %></tt>: As above, but will only include the Prototype core library,
-    #   which means you are able to use all basic AJAX functionality. For the script.aculo.us-based JavaScript helpers,
-    #   like visual effects, autocompletion, drag and drop and so on, you should use the method described above.
-    # * Use <tt><%= define_javascript_functions %></tt>: this will copy all the JavaScript support functions within a single
-    #   script block.
+    # Rails includes the Prototype JavaScript framework and the Scriptaculous
+    # JavaScript controls and visual effects library.  If you wish to use
+    # these libraries and their helpers (ActionView::Helpers::PrototypeHelper
+    # and ActionView::Helpers::ScriptaculousHelper), you must do one of the
+    # following:
     #
-    # For documentation on +javascript_include_tag+ see ActionView::Helpers::AssetTagHelper.
+    # * Use <tt><%= javascript_include_tag :defaults %></tt> in the HEAD 
+    #   section of your page (recommended): This function will return 
+    #   references to the JavaScript files created by the +rails+ command in
+    #   your <tt>public/javascripts</tt> directory. Using it is recommended as
+    #   the browser can then cache the libraries instead of fetching all the 
+    #   functions anew on every request.
+    # * Use <tt><%= javascript_include_tag 'prototype' %></tt>: As above, but 
+    #   will only include the Prototype core library, which means you are able
+    #   to use all basic AJAX functionality. For the Scriptaculous-based 
+    #   JavaScript helpers, like visual effects, autocompletion, drag and drop 
+    #   and so on, you should use the method described above.
+    # * Use <tt><%= define_javascript_functions %></tt>: this will copy all the
+    #   JavaScript support functions within a single script block. Not
+    #   recommended.
     #
-    # If you're the visual type, there's an AJAX movie[http://www.rubyonrails.com/media/video/rails-ajax.mov] demonstrating
-    # the use of form_remote_tag.
-    module JavaScriptHelper      
-      unless const_defined? :CALLBACKS
-        CALLBACKS       = 
-          [:uninitialized, :loading, :loaded, :interactive, :complete, :failure, :success].push((100..599).to_a).flatten
-        AJAX_OPTIONS    = [ :before, :after, :condition, :url, :asynchronous, :method, 
-          :insertion, :position, :form, :with, :update, :script ].concat(CALLBACKS)
+    # For documentation on +javascript_include_tag+ see 
+    # ActionView::Helpers::AssetTagHelper.
+    module JavaScriptHelper
+      unless const_defined? :JAVASCRIPT_PATH
         JAVASCRIPT_PATH = File.join(File.dirname(__FILE__), 'javascripts')
       end
       
-      # Returns a link that'll trigger a javascript +function+ using the 
+      # Returns a link that'll trigger a JavaScript +function+ using the 
       # onclick handler and return false after the fact.
       #
       # Examples:
       #   link_to_function "Greeting", "alert('Hello world!')"
       #   link_to_function(image_tag("delete"), "if confirm('Really?'){ do_delete(); }")
       def link_to_function(name, function, html_options = {})
+        html_options.symbolize_keys!
         content_tag(
           "a", name, 
-          {:href => "#", :onclick => "#{function}; return false;"}.merge(html_options.symbolize_keys)
+          html_options.merge({ 
+            :href => html_options[:href] || "#", 
+            :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function}; return false;" 
+          })
         )
       end
-
-      # Returns a link to a remote action defined by <tt>options[:url]</tt> 
-      # (using the url_for format) that's called in the background using 
-      # XMLHttpRequest. The result of that request can then be inserted into a
-      # DOM object whose id can be specified with <tt>options[:update]</tt>. 
-      # Usually, the result would be a partial prepared by the controller with
-      # either render_partial or render_partial_collection. 
-      #
-      # Examples:
-      #  link_to_remote "Delete this post", :update => "posts", :url => { :action => "destroy", :id => post.id }
-      #  link_to_remote(image_tag("refresh"), :update => "emails", :url => { :action => "list_emails" })
-      #
-      # You can also specify a hash for <tt>options[:update]</tt> to allow for
-      # easy redirection of output to an other DOM element if a server-side error occurs:
-      #
-      # Example:
-      #  link_to_remote "Delete this post",
-      #      :url => { :action => "destroy", :id => post.id },
-      #      :update => { :success => "posts", :failure => "error" }
-      #
-      # Optionally, you can use the <tt>options[:position]</tt> parameter to influence
-      # how the target DOM element is updated. It must be one of 
-      # <tt>:before</tt>, <tt>:top</tt>, <tt>:bottom</tt>, or <tt>:after</tt>.
-      #
-      # By default, these remote requests are processed asynchronous during 
-      # which various JavaScript callbacks can be triggered (for progress indicators and
-      # the likes). All callbacks get access to the <tt>request</tt> object,
-      # which holds the underlying XMLHttpRequest. 
-      #
-      # To access the server response, use <tt>request.responseText</tt>, to
-      # find out the HTTP status, use <tt>request.status</tt>.
-      #
-      # Example:
-      #   link_to_remote word,
-      #       :url => { :action => "undo", :n => word_counter },
-      #       :complete => "undoRequestCompleted(request)"
-      #
-      # The callbacks that may be specified are (in order):
-      #
-      # <tt>:loading</tt>::       Called when the remote document is being 
-      #                           loaded with data by the browser.
-      # <tt>:loaded</tt>::        Called when the browser has finished loading
-      #                           the remote document.
-      # <tt>:interactive</tt>::   Called when the user can interact with the 
-      #                           remote document, even though it has not 
-      #                           finished loading.
-      # <tt>:success</tt>::       Called when the XMLHttpRequest is completed,
-      #                           and the HTTP status code is in the 2XX range.
-      # <tt>:failure</tt>::       Called when the XMLHttpRequest is completed,
-      #                           and the HTTP status code is not in the 2XX
-      #                           range.
-      # <tt>:complete</tt>::      Called when the XMLHttpRequest is complete 
-      #                           (fires after success/failure if they are present).,
-      #                     
-      # You can further refine <tt>:success</tt> and <tt>:failure</tt> by adding additional 
-      # callbacks for specific status codes:
-      #
-      # Example:
-      #   link_to_remote word,
-      #       :url => { :action => "action" },
-      #       404 => "alert('Not found...? Wrong URL...?')",
-      #       :failure => "alert('HTTP Error ' + request.status + '!')"
-      #
-      # A status code callback overrides the success/failure handlers if present.
-      #
-      # If you for some reason or another need synchronous processing (that'll
-      # block the browser while the request is happening), you can specify 
-      # <tt>options[:type] = :synchronous</tt>.
-      #
-      # You can customize further browser side call logic by passing
-      # in JavaScript code snippets via some optional parameters. In
-      # their order of use these are:
-      #
-      # <tt>:confirm</tt>::      Adds confirmation dialog.
-      # <tt>:condition</tt>::    Perform remote request conditionally
-      #                          by this expression. Use this to
-      #                          describe browser-side conditions when
-      #                          request should not be initiated.
-      # <tt>:before</tt>::       Called before request is initiated.
-      # <tt>:after</tt>::        Called immediately after request was
-      #                          initiated and before <tt>:loading</tt>.
-      # <tt>:submit</tt>::       Specifies the DOM element ID that's used
-      #                          as the parent of the form elements. By 
-      #                          default this is the current form, but
-      #                          it could just as well be the ID of a
-      #                          table row or any other DOM element.
-      def link_to_remote(name, options = {}, html_options = {})  
-        link_to_function(name, remote_function(options), html_options)
-      end
-
-      # Periodically calls the specified url (<tt>options[:url]</tt>) every <tt>options[:frequency]</tt> seconds (default is 10).
-      # Usually used to update a specified div (<tt>options[:update]</tt>) with the results of the remote call.
-      # The options for specifying the target with :url and defining callbacks is the same as link_to_remote.
-      def periodically_call_remote(options = {})
-         frequency = options[:frequency] || 10 # every ten seconds by default
-         code = "new PeriodicalExecuter(function() {#{remote_function(options)}}, #{frequency})"
-         javascript_tag(code)
-      end
-
-      # Returns a form tag that will submit using XMLHttpRequest in the background instead of the regular 
-      # reloading POST arrangement. Even though it's using JavaScript to serialize the form elements, the form submission 
-      # will work just like a regular submission as viewed by the receiving side (all elements available in @params).
-      # The options for specifying the target with :url and defining callbacks is the same as link_to_remote.
-      #
-      # A "fall-through" target for browsers that doesn't do JavaScript can be specified with the :action/:method options on :html
-      #
-      #   form_remote_tag :html => { :action => url_for(:controller => "some", :action => "place") }
-      # The Hash passed to the :html key is equivalent to the options (2nd) argument in the FormTagHelper.form_tag method.
-      #
-      # By default the fall-through action is the same as the one specified in the :url (and the default method is :post).
-      def form_remote_tag(options = {})
-        options[:form] = true
-
-        options[:html] ||= {}
-        options[:html][:onsubmit] = "#{remote_function(options)}; return false;"
-        options[:html][:action] = options[:html][:action] || url_for(options[:url])
-        options[:html][:method] = options[:html][:method] || "post"
-
-        tag("form", options[:html], true)
-      end
       
-      # Returns a button input tag that will submit form using XMLHttpRequest in the background instead of regular
-      # reloading POST arrangement. <tt>options</tt> argument is the same as in <tt>form_remote_tag</tt>
-      def submit_to_remote(name, value, options = {})
-        options[:with] ||= 'Form.serialize(this.form)'
-
-        options[:html] ||= {}
-        options[:html][:type] = 'button'
-        options[:html][:onclick] = "#{remote_function(options)}; return false;"
-        options[:html][:name] = name
-        options[:html][:value] = value
-
-        tag("input", options[:html], false)
-      end
-      
-      # Returns a Javascript function (or expression) that'll update a DOM element according to the options passed.
-      #
-      # * <tt>:content</tt>: The content to use for updating. Can be left out if using block, see example.
-      # * <tt>:action</tt>: Valid options are :update (assumed by default), :empty, :remove
-      # * <tt>:position</tt> If the :action is :update, you can optionally specify one of the following positions: :before, :top, :bottom, :after.
+      # Returns a link that'll trigger a JavaScript +function+ using the 
+      # onclick handler.
       #
       # Examples:
-      #   <%= javascript_tag(update_element_function(
-      #         "products", :position => :bottom, :content => "<p>New product!</p>")) %>
-      #
-      #   <% replacement_function = update_element_function("products") do %>
-      #     <p>Product 1</p>
-      #     <p>Product 2</p>
-      #   <% end %>
-      #   <%= javascript_tag(replacement_function) %>
-      #
-      # This method can also be used in combination with remote method call where the result is evaluated afterwards to cause
-      # multiple updates on a page. Example:
-      #
-      #   # Calling view
-      #   <%= form_remote_tag :url => { :action => "buy" }, :complete => evaluate_remote_response %>
-      #   all the inputs here...
-      #
-      #   # Controller action
-      #   def buy
-      #     @product = Product.find(1)
-      #   end
-      #
-      #   # Returning view
-      #   <%= update_element_function(
-      #         "cart", :action => :update, :position => :bottom, 
-      #         :content => "<p>New Product: #{@product.name}</p>")) %>
-      #   <% update_element_function("status", :binding => binding) do %>
-      #     You've bought a new product!
-      #   <% end %>
-      #
-      # Notice how the second call doesn't need to be in an ERb output block since it uses a block and passes in the binding
-      # to render directly. This trick will however only work in ERb (not Builder or other template forms).
-      def update_element_function(element_id, options = {}, &block)
-        
-        content = escape_javascript(options[:content] || '')
-        content = escape_javascript(capture(&block)) if block
-        
-        javascript_function = case (options[:action] || :update)
-          when :update
-            if options[:position]
-              "new Insertion.#{options[:position].to_s.camelize}('#{element_id}','#{content}')"
-            else
-              "$('#{element_id}').innerHTML = '#{content}'"
-            end
-          
-          when :empty
-            "$('#{element_id}').innerHTML = ''"
-          
-          when :remove
-            "Element.remove('#{element_id}')"
-          
-          else
-            raise ArgumentError, "Invalid action, choose one of :update, :remove, :empty"
-        end
-        
-        javascript_function << ";\n"
-        options[:binding] ? concat(javascript_function, options[:binding]) : javascript_function
-      end
-      
-      # Returns 'eval(request.responseText)' which is the Javascript function that form_remote_tag can call in :complete to
-      # evaluate a multiple update return document using update_element_function calls.
-      def evaluate_remote_response
-        "eval(request.responseText)"
-      end
-
-      # Returns the javascript needed for a remote function.
-      # Takes the same arguments as link_to_remote.
-      # 
-      # Example:
-      #   <select id="options" onchange="<%= remote_function(:update => "options", :url => { :action => :update_options }) %>">
-      #     <option value="0">Hello</option>
-      #     <option value="1">World</option>
-      #   </select>
-      def remote_function(options)
-        javascript_options = options_for_ajax(options)
-
-        update = ''
-        if options[:update] and options[:update].is_a?Hash
-          update  = []
-          update << "success:'#{options[:update][:success]}'" if options[:update][:success]
-          update << "failure:'#{options[:update][:failure]}'" if options[:update][:failure]
-          update  = '{' + update.join(',') + '}'
-        elsif options[:update]
-          update << "'#{options[:update]}'"
-        end
-
-        function = update.empty? ? 
-          "new Ajax.Request(" :
-          "new Ajax.Updater(#{update}, "
-
-        function << "'#{url_for(options[:url])}'"
-        function << ", #{javascript_options})"
-
-        function = "#{options[:before]}; #{function}" if options[:before]
-        function = "#{function}; #{options[:after]}"  if options[:after]
-        function = "if (#{options[:condition]}) { #{function}; }" if options[:condition]
-        function = "if (confirm('#{escape_javascript(options[:confirm])}')) { #{function}; }" if options[:confirm]
-
-        return function
+      #   button_to_function "Greeting", "alert('Hello world!')"
+      #   button_to_function "Delete", "if confirm('Really?'){ do_delete(); }")
+      def button_to_function(name, function, html_options = {})
+        html_options.symbolize_keys!
+        tag(:input, html_options.merge({ 
+          :type => "button", :value => name, 
+          :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function};" 
+        }))
       end
 
       # Includes the Action Pack JavaScript libraries inside a single <script> 
       # tag. The function first includes prototype.js and then its core extensions,
       # (determined by filenames starting with "prototype").
-      # Afterwards, any additional scripts will be included in random order.
+      # Afterwards, any additional scripts will be included in undefined order.
       #
       # Note: The recommended approach is to copy the contents of
       # lib/action_view/helpers/javascripts/ into your application's
@@ -312,142 +97,6 @@ module ActionView
         javascript << '</script>'
       end
 
-      # Observes the field with the DOM ID specified by +field_id+ and makes
-      # an AJAX call when its contents have changed.
-      # 
-      # Required +options+ are:
-      # <tt>:url</tt>::       +url_for+-style options for the action to call
-      #                       when the field has changed.
-      # 
-      # Additional options are:
-      # <tt>:frequency</tt>:: The frequency (in seconds) at which changes to
-      #                       this field will be detected. Not setting this
-      #                       option at all or to a value equal to or less than
-      #                       zero will use event based observation instead of
-      #                       time based observation.
-      # <tt>:update</tt>::    Specifies the DOM ID of the element whose 
-      #                       innerHTML should be updated with the
-      #                       XMLHttpRequest response text.
-      # <tt>:with</tt>::      A JavaScript expression specifying the
-      #                       parameters for the XMLHttpRequest. This defaults
-      #                       to 'value', which in the evaluated context 
-      #                       refers to the new field value.
-      #
-      # Additionally, you may specify any of the options documented in
-      # link_to_remote.
-      def observe_field(field_id, options = {})
-        if options[:frequency] and options[:frequency] > 0
-          build_observer('Form.Element.Observer', field_id, options)
-        else
-          build_observer('Form.Element.EventObserver', field_id, options)
-        end
-      end
-      
-      # Like +observe_field+, but operates on an entire form identified by the
-      # DOM ID +form_id+. +options+ are the same as +observe_field+, except 
-      # the default value of the <tt>:with</tt> option evaluates to the
-      # serialized (request string) value of the form.
-      def observe_form(form_id, options = {})
-        if options[:frequency]
-          build_observer('Form.Observer', form_id, options)
-        else
-          build_observer('Form.EventObserver', form_id, options)
-        end
-      end
-      
-      # Returns a JavaScript snippet to be used on the AJAX callbacks for starting
-      # visual effects.
-      #
-      # This method requires the inclusion of the script.aculo.us JavaScript library.
-      #
-      # Example:
-      #   <%= link_to_remote "Reload", :update => "posts", 
-      #         :url => { :action => "reload" }, 
-      #         :complete => visual_effect(:highlight, "posts", :duration => 0.5 )
-      #
-      # If no element_id is given, it assumes "element" which should be a local
-      # variable in the generated JavaScript execution context. This can be used
-      # for example with drop_receiving_element:
-      #
-      #   <%= drop_receving_element (...), :loading => visual_effect(:fade) %>
-      #
-      # This would fade the element that was dropped on the drop receiving element.
-      #
-      # You can change the behaviour with various options, see
-      # http://script.aculo.us for more documentation.
-      def visual_effect(name, element_id = false, js_options = {})
-        element = element_id ? "'#{element_id}'" : "element"
-        js_options[:queue] = "'#{js_options[:queue]}'" if js_options[:queue]
-        "new Effect.#{name.to_s.camelize}(#{element},#{options_for_javascript(js_options)});"
-      end
-      
-      # Makes the element with the DOM ID specified by +element_id+ sortable
-      # by drag-and-drop and make an AJAX call whenever the sort order has
-      # changed. By default, the action called gets the serialized sortable
-      # element as parameters.
-      #
-      # This method requires the inclusion of the script.aculo.us JavaScript library.
-      #
-      # Example:
-      #   <%= sortable_element("my_list", :url => { :action => "order" }) %>
-      #
-      # In the example, the action gets a "my_list" array parameter 
-      # containing the values of the ids of elements the sortable consists 
-      # of, in the current order.
-      #
-      # You can change the behaviour with various options, see
-      # http://script.aculo.us for more documentation.
-      def sortable_element(element_id, options = {})
-        options[:with]     ||= "Sortable.serialize('#{element_id}')"
-        options[:onUpdate] ||= "function(){" + remote_function(options) + "}"
-        options.delete_if { |key, value| AJAX_OPTIONS.include?(key) }
-        
-        [:tag, :overlap, :constraint, :handle].each do |option|
-          options[option] = "'#{options[option]}'" if options[option]
-        end
-        
-        options[:containment] = array_or_string_for_javascript(options[:containment]) if options[:containment]
-        options[:only] = array_or_string_for_javascript(options[:only]) if options[:only]
-        
-        javascript_tag("Sortable.create('#{element_id}', #{options_for_javascript(options)})")
-      end
-      
-      # Makes the element with the DOM ID specified by +element_id+ draggable.
-      #
-      # This method requires the inclusion of the script.aculo.us JavaScript library.
-      #
-      # Example:
-      #   <%= draggable_element("my_image", :revert => true)
-      # 
-      # You can change the behaviour with various options, see
-      # http://script.aculo.us for more documentation. 
-      def draggable_element(element_id, options = {})
-        javascript_tag("new Draggable('#{element_id}', #{options_for_javascript(options)})")
-      end
-      
-      # Makes the element with the DOM ID specified by +element_id+ receive
-      # dropped draggable elements (created by draggable_element).
-      # and make an AJAX call  By default, the action called gets the DOM ID of the
-      # element as parameter.
-      #
-      # This method requires the inclusion of the script.aculo.us JavaScript library.
-      #
-      # Example:
-      #   <%= drop_receiving_element("my_cart", :url => { :controller => "cart", :action => "add" }) %>
-      #
-      # You can change the behaviour with various options, see
-      # http://script.aculo.us for more documentation.
-      def drop_receiving_element(element_id, options = {})
-        options[:with]     ||= "'id=' + encodeURIComponent(element.id)"
-        options[:onDrop]   ||= "function(element){" + remote_function(options) + "}"
-        options.delete_if { |key, value| AJAX_OPTIONS.include?(key) }
-        
-        options[:accept] = array_or_string_for_javascript(options[:accept]) if options[:accept]    
-        options[:hoverclass] = "'#{options[:hoverclass]}'" if options[:hoverclass]
-        
-        javascript_tag("Droppables.add('#{element_id}', #{options_for_javascript(options)})")
-      end
-
       # Escape carrier returns and single and double quotes for JavaScript segments.
       def escape_javascript(javascript)
         (javascript || '').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
@@ -463,7 +112,7 @@ module ActionView
         "\n//#{cdata_section("\n#{content}\n//")}\n"
       end
       
-    private
+    protected
       def options_for_javascript(options)
         '{' + options.map {|k, v| "#{k}:#{v}"}.sort.join(', ') + '}'
       end
@@ -476,51 +125,6 @@ module ActionView
         end
         js_option
       end
-      
-      def options_for_ajax(options)
-        js_options = build_callbacks(options)
-        
-        js_options['asynchronous'] = options[:type] != :synchronous
-        js_options['method']       = method_option_to_s(options[:method]) if options[:method]
-        js_options['insertion']    = "Insertion.#{options[:position].to_s.camelize}" if options[:position]
-        js_options['evalScripts']  = options[:script].nil? || options[:script]
-
-        if options[:form]
-          js_options['parameters'] = 'Form.serialize(this)'
-        elsif options[:submit]
-          js_options['parameters'] = "Form.serialize(document.getElementById('#{options[:submit]}'))"
-        elsif options[:with]
-          js_options['parameters'] = options[:with]
-        end
-        
-        options_for_javascript(js_options)
-      end
-
-      def method_option_to_s(method) 
-        (method.is_a?(String) and !method.index("'").nil?) ? method : "'#{method}'"
-      end
-      
-      def build_observer(klass, name, options = {})
-        options[:with] ||= 'value' if options[:update]
-        callback = remote_function(options)
-        javascript  = "new #{klass}('#{name}', "
-        javascript << "#{options[:frequency]}, " if options[:frequency]
-        javascript << "function(element, value) {"
-        javascript << "#{callback}})"
-        javascript_tag(javascript)
-      end
-            
-      def build_callbacks(options)
-        callbacks = {}
-        options.each do |callback, code|
-          if CALLBACKS.include?(callback)
-            name = 'on' + callback.to_s.capitalize
-            callbacks[name] = "function(request){#{code}}"
-          end
-        end
-        callbacks
-      end
-      
     end
     
     JavascriptHelper = JavaScriptHelper unless const_defined? :JavascriptHelper