actionpack 1.5.1 → 1.6.0

data/lib/action_controller/request.rb

@@ -77,10 +77,6 @@ module ActionController
       (%r{^\w+\://[^/]+(/.*|$)$} =~ env['REQUEST_URI']) ? $1 : env['REQUEST_URI'] # Remove domain, which webrick puts into the request_uri.
     end
 
-    def path_info
-      (/^(.*)\.html$/ =~ env['PATH_INFO']) ? $1 : env['PATH_INFO']
-    end
-
     def protocol
       env["HTTPS"] == "on" ? 'https://' : 'http://'
     end
@@ -88,9 +84,20 @@ module ActionController
     def ssl?
       protocol == 'https://'
     end
-
+  
+    # returns the interpreted path to requested resource after
+    # all the installation directory of this application was taken into account
     def path
-      (path_info && !path_info.empty?) ? path_info : (request_uri ? request_uri.split('?').first : '')
+      path = request_uri ? request_uri.split('?').first : ''
+
+      # cut off the part of the url which leads to the installation directory of this app
+      path[relative_url_root.length..-1]
+    end    
+    
+    # returns the path minus the web server relative 
+    # installation directory
+    def relative_url_root
+      File.dirname(env["SCRIPT_NAME"].to_s).gsub /(^\.$|^\/$)/, ''
     end
 
     def port

data/lib/action_controller/routing.rb

@@ -47,13 +47,35 @@ module ActionController
         
         used_names = @requirements.inject({}) {|hash, (k, v)| hash[k] = true; hash} # Mark requirements as used so they don't get put in the query params
         components = @items.collect do |item|
+
           if item.kind_of? Symbol
+            collection = false
+
+            if /^\*/ =~ item.to_s
+              collection = true
+              item = item.to_s.sub(/^\*/,"").intern
+            end
+
             used_names[item] = true
             value = options[item] || defaults[item] || @defaults[item]
             return nil, requirements_for(item) unless passes_requirements?(item, value)
+
             defaults = {} unless defaults == {} || value == defaults[item] # Stop using defaults if this component isn't the same as the default.
-            (value.nil? || item == :controller) ? value : CGI.escape(value.to_s)
-          else item
+
+      	    if value.nil? || item == :controller
+              value
+            elsif collection
+              if value.kind_of?(Array)
+                value = value.collect {|v| Routing.extract_parameter_value(v)}.join('/')
+              else
+                value = Routing.extract_parameter_value(value).gsub(/%2F/, "/")
+              end
+              value
+            else
+              Routing.extract_parameter_value(value)
+            end
+          else
+            item
           end
         end
         
@@ -96,6 +118,12 @@ module ActionController
             end
             options[:controller] = controller_class.controller_path
             return nil, requirements_for(:controller) unless passes_requirements?(:controller, options[:controller])
+          elsif /^\*/ =~ item.to_s
+            value = components.empty? ? @defaults[item].clone : components.clone
+            value.collect! {|c| CGI.unescape c}
+            components = []
+            def value.to_s() self.join('/') end
+            options[item.to_s.sub(/^\*/,"").intern] = value
           elsif item.kind_of? Symbol
             value = components.shift || @defaults[item]
             return nil, requirements_for(item) unless passes_requirements?(item, value)
@@ -142,7 +170,7 @@ module ActionController
         end
       
         def items=(path)
-          items = path.split('/').collect {|c| (/^:(\w+)$/ =~ c) ? $1.intern : c} if path.kind_of?(String) # split and convert ':xyz' to symbols
+          items = path.split('/').collect {|c| (/^(:|\*)(\w+)$/ =~ c) ? (($1 == ':' ) ? $2.intern : "*#{$2}".intern) : c} if path.kind_of?(String) # split and convert ':xyz' to symbols
           items.shift if items.first == ""
           items.pop if items.last == ""
           @items = items
@@ -172,6 +200,7 @@ module ActionController
           end
         end
         def requirements_for(name)
+          name = name.to_s.sub(/^\*/,"").intern if (/^\*/ =~ name.inspect)
           presence = (@defaults.key?(name) && @defaults[name].nil?)
           requirement = case @requirements[name]
             when nil then nil
@@ -295,6 +324,11 @@ module ActionController
       end
     end
     
+    def self.extract_parameter_value(parameter) #:nodoc:
+      value = (parameter.respond_to?(:to_param) ? parameter.to_param : parameter).to_s
+      CGI.escape(value)
+    end
+
     def self.draw(*args, &block) #:nodoc:
       Routes.draw(*args) {|*args| block.call(*args)}
     end

data/lib/action_controller/test_process.rb

@@ -168,7 +168,7 @@ module ActionController #:nodoc:
     
     # do we have a flash? 
     def has_flash?
-      !session['flash'].nil?
+      !session['flash'].empty?
     end
 
     # do we have a flash that has contents?
@@ -277,6 +277,10 @@ module Test
           
           get(@response.redirected_to.delete(:action), @response.redirected_to.stringify_keys)
         end
-    end
+
+        def assigns(name)
+          @response.template.assigns[name.to_s]
+        end
+      end
   end
-end
+end

data/lib/action_controller/url_rewriter.rb

@@ -2,13 +2,13 @@ module ActionController
   # Rewrites URLs for Base.redirect_to and Base.url_for in the controller.
 
   class UrlRewriter #:nodoc:
-    RESERVED_OPTIONS = [:anchor, :params, :only_path, :host, :protocol]
+    RESERVED_OPTIONS = [:anchor, :params, :only_path, :host, :protocol, :application_prefix]
     def initialize(request, parameters)
       @request, @parameters = request, parameters
       @rewritten_path = @request.path ? @request.path.dup : ""
     end
     
-    def rewrite(options = {})
+    def rewrite(options = {})      
       rewrite_url(rewrite_path(options), options)
     end
 
@@ -20,11 +20,12 @@ module ActionController
 
     private
       def rewrite_url(path, options)        
+      
         rewritten_url = ""
         rewritten_url << (options[:protocol] || @request.protocol) unless options[:only_path]
         rewritten_url << (options[:host] || @request.host_with_port) unless options[:only_path]
 
-        rewritten_url << options[:application_prefix] if options[:application_prefix]
+        rewritten_url << (options[:application_prefix] || @request.relative_url_root) 
         rewritten_url << path
         rewritten_url << "##{options[:anchor]}" if options[:anchor]
 
@@ -95,7 +96,7 @@ module ActionController
           key = CGI.escape key
           key += '[]' if value.class == Array
           value = [ value ] unless value.class == Array
-          value.each { |val| elements << "#{key}=#{CGI.escape(val.to_s)}" }
+          value.each { |val| elements << "#{key}=#{Routing.extract_parameter_value(val)}" }
         end
         
         query_string << ("?" + elements.join("&")) unless elements.empty?

data/lib/action_view/helpers/asset_tag_helper.rb

@@ -33,8 +33,7 @@ module ActionView
       #     <script language="JavaScript" type="text/javascript" src="/elsewhere/cools.js"></script>
       def javascript_include_tag(*sources)
         sources.collect { |source|
-          source = "/javascripts/#{source}" unless source.include?("/")
-          source = "#{source}.js" unless source.include?(".")
+          source = compute_public_path(source, 'javascripts', 'js')        
           content_tag("script", "", "language" => "JavaScript", "type" => "text/javascript", "src" => source)
         }.join("\n")
       end
@@ -49,11 +48,43 @@ module ActionView
       #     <link href="/css/stylish.css" media="screen" rel="Stylesheet" type="text/css" />
       def stylesheet_link_tag(*sources)
         sources.collect { |source|
-          source = "/stylesheets/#{source}" unless source.include?("/")
-          source = "#{source}.css" unless source.include?(".")
+          source = compute_public_path(source, 'stylesheets', 'css')
           tag("link", "rel" => "Stylesheet", "type" => "text/css", "media" => "screen", "href" => source)
         }.join("\n")
       end
+
+      # Returns an image tag converting the +options+ instead html options on the tag, but with these special cases:
+      #
+      # * <tt>:alt</tt>  - If no alt text is given, the file name part of the +src+ is used (capitalized and without the extension)
+      # * <tt>:size</tt> - Supplied as "XxY", so "30x45" becomes width="30" and height="45"
+      #
+      # The +src+ can be supplied as a...
+      # * full path, like "/my_images/image.gif"
+      # * file name, like "rss.gif", that gets expanded to "/images/rss.gif"
+      # * file name without extension, like "logo", that gets expanded to "/images/logo.png"
+      def image_tag(source, options = {})
+        options.symbolize_keys
+                
+        options[:src] = compute_public_path(source, 'images', 'png')
+        options[:alt] ||= source.split("/").last.split(".").first.capitalize
+        
+        if options[:size]
+          options[:width], options[:height] = options[:size].split("x")
+          options.delete :size
+        end
+
+        tag("img", options)
+      end
+      
+      private
+      
+        def compute_public_path(source, dir, ext)
+          source = "/#{dir}/#{source}" unless source.include?("/")
+          source = "#{source}.#{ext}" unless source.include?(".")
+          source = "#{@request.relative_url_root}#{source}" 
+          source
+        end
+        
     end
   end
 end

data/lib/action_view/helpers/capture_helper.rb

@@ -0,0 +1,95 @@
+module ActionView
+  module Helpers
+    # Capture lets you extract parts of code into instance variables which
+    # can be used in other points of the template or even layout file.
+    #
+    # == Capturing a block into an instance variable
+    #
+    #   <% @script = capture do %>
+    #     [some html...]
+    #   <% end %>
+    #  
+    #
+    # == Add javascript to header using content_for
+    #
+    # content_for("name") is a wrapper for capture which will store the 
+    # fragment in a instance variable similar to @content_for_layout.
+    #
+    # layout.rhtml:
+    #
+    #   <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+    #   <head>
+    #	    <title>layout with js</title>
+    #	    <script type="text/javascript">
+    #	    <%= @content_for_script %>
+    #   	</script>
+    #   </head>
+    #   <body>
+    #     <%= @content_for_layout %>
+    #   </body>
+    #   </html>
+    #
+    # view.rhtml
+    #   
+    #   This page shows an alert box!
+    #
+    #   <% content_for("script") do %>
+    #     alert('hello world')
+    #   <% end %>
+    #
+    #   Normal view text
+    module CaptureHelper
+      # Capture allows you to extract a part of the template into an 
+      # instance variable. You can use this instance variable anywhere
+      # in your templates and even in your layout. 
+      # 
+      # Example:
+      # 
+      #   <% @greeting = capture do %>
+      #     Welcome To my shiny new web page!
+      #   <% end %>      
+      def capture(&block)
+        # execute the block
+        buffer = eval("_erbout", block.binding)
+        pos = buffer.length
+        block.call
+        
+        # extract the block 
+        data = buffer[pos..-1]
+        
+        # replace it in the original with empty string
+        buffer[pos..-1] = ''
+        
+        data
+      end
+      
+      # Content_for will store the given block
+      # in an instance variable for later use in another template
+      # or in the layout. 
+      # 
+      # The name of the instance variable is content_for_<name> 
+      # to stay consistent with @content_for_layout which is used 
+      # by ActionView's layouts
+      # 
+      # Example:
+      # 
+      #   <% content_for("header") do %>
+      #     alert('hello world')
+      #   <% end %>
+      #
+      # You can use @content_for_header anywhere in your templates
+      def content_for(name, &block)                      
+        base = controller.instance_variable_get(instance_var_name(name)) || ""
+        data = capture(&block)
+        controller.instance_variable_set(instance_var_name(name), base + data)
+        data
+      end
+      
+      private
+      
+        def instance_var_name(name) #:nodoc#
+          "@content_for_#{name}"
+        end
+    end
+  end
+end

data/lib/action_view/helpers/form_helper.rb

@@ -152,7 +152,7 @@ module ActionView
         @object_name, @method_name = object_name, method_name
         @template_object, @local_binding = template_object, local_binding
         if @object_name.sub!(/\[\]$/,"")
-          @auto_index = @template_object.instance_variable_get("@#{Regexp.last_match.pre_match}").id
+          @auto_index = @template_object.instance_variable_get("@#{Regexp.last_match.pre_match}").id_before_type_cast
         end
       end
 

data/lib/action_view/helpers/form_options_helper.rb

@@ -83,6 +83,7 @@ module ActionView
         options_for_select = container.inject([]) do |options, element|
           if element.respond_to?(:first) && element.respond_to?(:last)
             is_selected = ( (selected.respond_to?(:include?) ? selected.include?(element.last) : element.last == selected) )
+            is_selected = ( (selected.respond_to?(:include?) && !selected.is_a?(String) ? selected.include?(element.last) : element.last == selected) )
             if is_selected
               options << "<option value=\"#{html_escape(element.last.to_s)}\" selected=\"selected\">#{html_escape(element.first.to_s)}</option>"
             else
@@ -90,6 +91,7 @@ module ActionView
             end
           else
             is_selected = ( (selected.respond_to?(:include?) ? selected.include?(element) : element == selected) )
+            is_selected = ( (selected.respond_to?(:include?) && !selected.is_a?(String) ? selected.include?(element) : element == selected) )
             options << ((is_selected) ? "<option selected=\"selected\">#{html_escape(element.to_s)}</option>" : "<option>#{html_escape(element.to_s)}</option>")
           end
         end

data/lib/action_view/helpers/form_tag_helper.rb

@@ -5,6 +5,9 @@ module ActionView
   module Helpers
     # Provides a number of methods for creating form tags that doesn't rely on conventions with an object assigned to the template like
     # FormHelper does. With the FormTagHelper, you provide the names and values yourself.
+    #
+    # NOTE: The html options disabled, readonly, and multiple can all be treated as booleans. So specifying <tt>disabled => :true</tt>
+    # will give <tt>disabled="disabled"</tt>.
     module FormTagHelper
       # Starts a form tag that points the action to an url configured with <tt>url_for_options</tt> just like
       # ActionController::Base#url_for. The method for the form defaults to POST.
@@ -14,9 +17,9 @@ module ActionView
       def form_tag(url_for_options = {}, options = {}, *parameters_for_url)
         html_options = { "method" => "post" }.merge(options.stringify_keys)
 
-        if html_options[:multipart]
+        if html_options["multipart"]
           html_options["enctype"] = "multipart/form-data"
-          html_options.delete(:multipart)
+          html_options.delete("multipart")
         end
 
         html_options["action"] = url_for(url_for_options, *parameters_for_url)
@@ -31,11 +34,11 @@ module ActionView
       end
 
       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(convert_options(options)))
       end
 
       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(convert_options(options)))
       end
 
       def hidden_field_tag(name, value = nil, options = {})
@@ -43,11 +46,11 @@ module ActionView
       end
 
       def file_field_tag(name, options = {})
-        text_field_tag(name, nil, options.stringify_keys.update("type" => "file"))
+        text_field_tag(name, nil, convert_options(options).update("type" => "file"))
       end
 
       def password_field_tag(name = "password", value = nil, options = {})
-        text_field_tag(name, value, options.stringify_keys.update("type" => "password"))
+        text_field_tag(name, value, convert_options(options).update("type" => "password"))
       end
 
       def text_area_tag(name, content = nil, options = {})
@@ -57,24 +60,39 @@ module ActionView
           options.delete("size")
         end
 
-        content_tag("textarea", content, { "name" => name, "id" => name }.update(options.stringify_keys))
+        content_tag("textarea", content, { "name" => name, "id" => name }.update(convert_options(options)))
       end
 
       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 = { "type" => "checkbox", "name" => name, "id" => name, "value" => value }.update(convert_options(options))
         html_options["checked"] = "checked" if checked
         tag("input", html_options)
       end
 
       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 = { "type" => "radio", "name" => name, "id" => name, "value" => value }.update(convert_options(options))
         html_options["checked"] = "checked" if checked
         tag("input", html_options)
       end
 
       def submit_tag(value = "Save changes", options = {})
-        tag("input", { "type" => "submit", "name" => "submit", "value" => value }.update(options.stringify_keys))
+        tag("input", { "type" => "submit", "name" => "submit", "value" => value }.update(convert_options(options)))
       end
+      
+      private
+        def convert_options(options)
+          options = options.stringify_keys
+          %w( disabled readonly multiple ).each { |a| boolean_attribute(options, a) }
+          options
+        end
+        
+        def boolean_attribute(options, attribute)
+          if options[attribute]
+            options[attribute] = attribute
+          else
+            options.delete attribute
+          end
+        end
     end
   end
 end

data/lib/action_view/helpers/javascript_helper.rb

@@ -0,0 +1,192 @@
+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.
+    #
+    # To be able to use the Javascript helpers, you must either call <tt><%= define_javascript_functions %></tt> (which returns all
+    # the Javascript support functions in a <script> block) or reference the Javascript library using 
+    # <tt><%= javascript_include_tag "prototype" %></tt> (which looks for the library in /javascripts/prototype.js). The latter is
+    # recommended as the browser can then cache the library instead of fetching all the functions anew on every request.
+    #
+    # 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]
+        JAVASCRIPT_PATH = File.join(File.dirname(__FILE__), 'javascripts')
+      end
+      
+      # 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 = {})
+        content_tag(
+          "a", name, 
+          html_options.symbolize_keys.merge(:href => "#", :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" })
+      #
+      # By default, these remote requests are processed asynchronous during 
+      # which various callbacks can be triggered (for progress indicators and
+      # the likes).
+      #
+      # Example:
+      #   link_to_remote word,
+      #       :url => { :action => "undo", :n => word_counter },
+      #       :complete => "undoRequestCompleted(request)"
+      #
+      # The callbacks that may be specified are:
+      #
+      # <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>:complete</tt>::      Called when the XMLHttpRequest is complete.
+      #
+      # 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>.
+      def link_to_remote(name, options = {}, html_options = {})  
+        link_to_function(name, remote_function(options), html_options)
+      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.
+      def form_remote_tag(options = {})
+        options[:form] = true
+
+        options[:html] ||= { }
+        options[:html][:onsubmit] = "#{remote_function(options)}; return false;"
+
+        tag("form", options[:html], true)
+      end
+
+      def remote_function(options) #:nodoc: for now
+        javascript_options = options_for_ajax(options)
+
+        function = options[:update] ? 
+          "new Ajax.Updater('#{options[:update]}', " :
+          "new Ajax.Request("
+
+        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]
+
+        return function
+      end
+
+      # Includes the Action Pack Javascript library inside a single <script> 
+      # tag.
+      #
+      # Note: The recommended approach is to copy the contents of
+      # lib/action_view/helpers/javascripts/ into your application's
+      # public/javascripts/ directory, and use +javascript_include_tag+ to 
+      # create remote <script> links.
+      def define_javascript_functions
+        javascript = '<script type="text/javascript">'
+        Dir.glob(File.join(JAVASCRIPT_PATH, '*')).each do |filename|
+          javascript << "\n" << IO.read(filename)
+        end
+        javascript << '</script>'
+      end
+
+      # Observes the field with the DOM ID specified by +field_id+ and makes
+      # an Ajax when its contents have changed.
+      # 
+      # Required +options+ are:
+      # <tt>:frequency</tt>:: The frequency (in seconds) at which changes to
+      #                       this field will be detected.
+      # <tt>:url</tt>::       +url_for+-style options for the action to call
+      #                       when the field has changed.
+      # 
+      # Additional options are:
+      # <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 = {})
+        build_observer('Form.Element.Observer', field_id, options)
+      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 = {})
+        build_observer('Form.Observer', form_id, options)
+      end
+
+    private
+      def escape_javascript(javascript)
+        (javascript || '').gsub('"', '\"')
+      end
+      
+      def options_for_ajax(options)
+        js_options = build_callbacks(options)
+        
+        js_options['asynchronous'] = options[:type] != :synchronous
+        js_options['method'] = options[:method] if options[:method]
+        
+        if options[:form]
+          js_options['parameters'] = 'Form.serialize(this)'
+        elsif options[:with]
+          js_options['parameters'] = options[:with]
+        end
+        
+        '{' + js_options.map {|k, v| "#{k}:#{v}"}.join(', ') + '}'
+      end
+      
+      def build_observer(klass, name, options = {})
+        options[:with] ||= 'value' if options[:update]
+        callback = remote_function(options)
+        javascript = '<script type="text/javascript">'
+        javascript << "new #{klass}('#{name}', "
+        javascript << "#{options[:frequency]}, function(element, value) {"
+        javascript << "#{callback}})</script>"
+      end
+            
+      def build_callbacks(options)
+        CALLBACKS.inject({}) do |callbacks, callback|
+          if options[callback]
+            name = 'on' + callback.to_s.capitalize
+            code = escape_javascript(options[callback])
+            callbacks[name] = "function(request){#{code}}"
+          end
+          callbacks
+        end
+      end
+    end
+  end
+end