actionpack 1.12.5 → 1.13.0

data/lib/action_view/helpers/number_helper.rb

@@ -1,43 +1,64 @@
 module ActionView
-  module Helpers
-    # Provides methods for converting a number into a formatted string that currently represents
-    # one of the following forms: phone number, percentage, money, or precision level.
+  module Helpers #:nodoc:
+    # Provides methods for converting a numbers into formatted strings.
+    # Methods are provided for phone numbers, currency, percentage,
+    # precision, positional notation, and file size.
     module NumberHelper
-
-      # Formats a +number+ into a US phone number string. The +options+ can be a hash used to customize the format of the output.
-      # The area code can be surrounded by parentheses by setting +:area_code+ to true; default is false
-      # The delimiter can be set using +:delimiter+; default is "-"
-      # Examples:
-      #   number_to_phone(1235551234)   => 123-555-1234
-      #   number_to_phone(1235551234, {:area_code => true})   => (123) 555-1234
-      #   number_to_phone(1235551234, {:delimiter => " "})    => 123 555 1234
-      #   number_to_phone(1235551234, {:area_code => true, :extension => 555})  => (123) 555-1234 x 555
+      # Formats a +number+ into a US phone number. You can customize the format
+      # in the +options+ hash.
+      # * <tt>:area_code</tt>  - Adds parentheses around the area code.
+      # * <tt>:delimiter</tt>  - Specifies the delimiter to use, defaults to "-".
+      # * <tt>:extension</tt>  - Specifies an extension to add to the end of the
+      #   generated number
+      # * <tt>:country_code</tt>  - Sets the country code for the phone number.
+      #
+      #  number_to_phone(1235551234)   => 123-555-1234
+      #  number_to_phone(1235551234, :area_code => true)   => (123) 555-1234
+      #  number_to_phone(1235551234, :delimiter => " ")    => 123 555 1234
+      #  number_to_phone(1235551234, :area_code => true, :extension => 555)  => (123) 555-1234 x 555
+      #  number_to_phone(1235551234, :country_code => 1)
       def number_to_phone(number, options = {})
-        options   = options.stringify_keys
-        area_code = options.delete("area_code") { false }
-        delimiter = options.delete("delimiter") { "-" }
-        extension = options.delete("extension") { "" }
+        number       = number.to_s.strip unless number.nil?
+        options      = options.stringify_keys
+        area_code    = options["area_code"] || nil
+        delimiter    = options["delimiter"] || "-"
+        extension    = options["extension"].to_s.strip || nil
+        country_code = options["country_code"] || nil
+
         begin
-          str = area_code == true ? number.to_s.gsub(/([0-9]{3})([0-9]{3})([0-9]{4})/,"(\\1) \\2#{delimiter}\\3") : number.to_s.gsub(/([0-9]{3})([0-9]{3})([0-9]{4})/,"\\1#{delimiter}\\2#{delimiter}\\3")
-          extension.to_s.strip.empty? ? str : "#{str} x #{extension.to_s.strip}"
+          str = ""
+          str << "+#{country_code}#{delimiter}" unless country_code.blank?
+          str << if area_code
+            number.gsub!(/([0-9]{1,3})([0-9]{3})([0-9]{4}$)/,"(\\1) \\2#{delimiter}\\3")
+          else
+            number.gsub!(/([0-9]{1,3})([0-9]{3})([0-9]{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
+          end
+          str << " x #{extension}" unless extension.blank?
+          str
         rescue
           number
         end
       end
 
-      # Formats a +number+ into a currency string. The +options+ hash can be used to customize the format of the output.
-      # The +number+ can contain a level of precision using the +precision+ key; default is 2
-      # The currency type can be set using the +unit+ key; default is "$"
-      # The unit separator can be set using the +separator+ key; default is "."
-      # The delimiter can be set using the +delimiter+ key; default is ","
-      # Examples:
-      #    number_to_currency(1234567890.50)     => $1,234,567,890.50
-      #    number_to_currency(1234567890.506)    => $1,234,567,890.51
-      #    number_to_currency(1234567890.50, {:unit => "&pound;", :separator => ",", :delimiter => ""}) => &pound;1234567890,50
+      # Formats a +number+ into a currency string. You can customize the format
+      # in the +options+ hash.
+      # * <tt>:precision</tt>  -  Sets the level of precision, defaults to 2
+      # * <tt>:unit</tt>  - Sets the denomination of the currency, defaults to "$"
+      # * <tt>:separator</tt>  - Sets the separator between the units, defaults to "."
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter, defaults to ","
+      #
+      #  number_to_currency(1234567890.50)     => $1,234,567,890.50
+      #  number_to_currency(1234567890.506)    => $1,234,567,890.51
+      #  number_to_currency(1234567890.506, :precision => 3)    => $1,234,567,890.506
+      #  number_to_currency(1234567890.50, :unit => "&pound;", :separator => ",", :delimiter => "") 
+      #     => &pound;1234567890,50
       def number_to_currency(number, options = {})
-        options = options.stringify_keys
-        precision, unit, separator, delimiter = options.delete("precision") { 2 }, options.delete("unit") { "$" }, options.delete("separator") { "." }, options.delete("delimiter") { "," }
-        separator = "" unless precision > 0
+        options   = options.stringify_keys
+        precision = options["precision"] || 2
+        unit      = options["unit"] || "$"
+        separator = precision > 0 ? options["separator"] || "." : ""
+        delimiter = options["delimiter"] || ","
+        
         begin
           parts = number_with_precision(number, precision).split('.')
           unit + number_with_delimiter(parts[0], delimiter) + separator + parts[1].to_s
@@ -46,16 +67,19 @@ module ActionView
         end
       end
 
-      # Formats a +number+ as into a percentage string. The +options+ hash can be used to customize the format of the output.
-      # The +number+ can contain a level of precision using the +precision+ key; default is 3
-      # The unit separator can be set using the +separator+ key; default is "."
-      # Examples:
-      #   number_to_percentage(100)    => 100.000%
-      #   number_to_percentage(100, {:precision => 0}) => 100%
-      #   number_to_percentage(302.0574, {:precision => 2})  => 302.06%
+      # Formats a +number+ as a percentage string. You can customize the
+      # format in the +options+ hash.
+      # * <tt>:precision</tt>  - Sets the level of precision, defaults to 3
+      # * <tt>:separator</tt>  - Sets the separator between the units, defaults to "."
+      #
+      #  number_to_percentage(100)    => 100.000%
+      #  number_to_percentage(100, {:precision => 0})   => 100%
+      #  number_to_percentage(302.0574, {:precision => 2})   => 302.06%
       def number_to_percentage(number, options = {})
-        options = options.stringify_keys
-        precision, separator = options.delete("precision") { 3 }, options.delete("separator") { "." }
+        options   = options.stringify_keys
+        precision = options["precision"] || 3
+        separator = options["separator"] || "."
+        
         begin
           number = number_with_precision(number, precision)
           parts = number.split('.')
@@ -69,41 +93,63 @@ module ActionView
         end
       end
 
-      # Formats a +number+ with a +delimiter+.
-      # Example:
-      #    number_with_delimiter(12345678) => 12,345,678
-      def number_with_delimiter(number, delimiter=",")
-        number.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+      # Formats a +number+ with grouped thousands using +delimiter+. You
+      # can customize the format in the +options+ hash.
+      # * <tt>:delimiter</tt>  - Sets the thousands delimiter, defaults to ","
+      # * <tt>:separator</tt>  - Sets the separator between the units, defaults to "."
+      #
+      #  number_with_delimiter(12345678)      => 12,345,678
+      #  number_with_delimiter(12345678.05)   => 12,345,678.05
+      #  number_with_delimiter(12345678, :delimiter => ".")   => 12.345.678
+      def number_with_delimiter(number, delimiter=",", separator=".")
+        begin
+          parts = number.to_s.split(separator)
+          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
+          parts.join separator
+        rescue
+          number
+        end
       end
-
-      # Returns a formatted-for-humans file size.
+      
+      # Formats a +number+ with the specified level of +precision+. The default
+      # level of precision is 3.
+      #
+      #  number_with_precision(111.2345)    => 111.235
+      #  number_with_precision(111.2345, 2) => 111.24
+      def number_with_precision(number, precision=3)
+        "%01.#{precision}f" % number
+      rescue
+        number
+      end
+      
+      # Formats the bytes in +size+ into a more understandable representation.
+      # Useful for reporting file sizes to users. This method returns nil if 
+      # +size+ cannot be converted into a number. You can change the default 
+      # precision of 1 in +precision+.
       # 
-      # Examples:
-      #   human_size(123)          => 123 Bytes
-      #   human_size(1234)         => 1.2 KB
-      #   human_size(12345)        => 12.1 KB
-      #   human_size(1234567)      => 1.2 MB
-      #   human_size(1234567890)   => 1.1 GB
-      def number_to_human_size(size)
+      #  number_to_human_size(123)           => 123 Bytes
+      #  number_to_human_size(1234)          => 1.2 KB
+      #  number_to_human_size(12345)         => 12.1 KB
+      #  number_to_human_size(1234567)       => 1.2 MB
+      #  number_to_human_size(1234567890)    => 1.1 GB
+      #  number_to_human_size(1234567890123) => 1.1 TB
+      #  number_to_human_size(1234567, 2)    => 1.18 MB
+      def number_to_human_size(size, precision=1)
+        size = Kernel.Float(size)
         case 
-          when size < 1.kilobyte: '%d Bytes' % size
-          when size < 1.megabyte: '%.1f KB'  % (size / 1.0.kilobyte)
-          when size < 1.gigabyte: '%.1f MB'  % (size / 1.0.megabyte)
-          when size < 1.terabyte: '%.1f GB'  % (size / 1.0.gigabyte)
-          else                    '%.1f TB'  % (size / 1.0.terabyte)
+          when size == 1        : "1 Byte"
+          when size < 1.kilobyte: "%d Bytes" % size
+          when size < 1.megabyte: "%.#{precision}f KB"  % (size / 1.0.kilobyte)
+          when size < 1.gigabyte: "%.#{precision}f MB"  % (size / 1.0.megabyte)
+          when size < 1.terabyte: "%.#{precision}f GB"  % (size / 1.0.gigabyte)
+          else                    "%.#{precision}f TB"  % (size / 1.0.terabyte)
         end.sub('.0', '')
       rescue
         nil
       end
       
       alias_method :human_size, :number_to_human_size # deprecated alias
-
-      # Formats a +number+ with a level of +precision+.
-      # Example:
-      #    number_with_precision(111.2345) => 111.235
-      def number_with_precision(number, precision=3)
-        sprintf("%01.#{precision}f", number)
-      end
+      deprecate :human_size => :number_to_human_size
     end
   end
 end

data/lib/action_view/helpers/prototype_helper.rb

@@ -1,4 +1,3 @@
-require File.dirname(__FILE__) + '/javascript_helper'
 require 'set'
 
 module ActionView
@@ -39,7 +38,7 @@ module ActionView
       # 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. 
+      # render :partial. 
       #
       # Examples:
       #   link_to_remote "Delete this post", :update => "posts", 
@@ -60,6 +59,12 @@ module ActionView
       # 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>.
       #
+      # The method used is by default POST. You can also specify GET or you
+      # can simulate PUT or DELETE over POST. All specified with <tt>options[:method]</tt>
+      #
+      # Example:
+      #   link_to_remote "Destroy", :url => person_url(:id => person), :method => :delete
+      #
       # 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 
@@ -159,15 +164,20 @@ module ActionView
       #
       # 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 = {})
+      #
+      # form_remote_tag also takes a block, like form_tag:
+      #   <% form_remote_tag :url => '/posts' do -%>
+      #     <div><%= submit_tag 'Save' %></div>
+      #   <% end -%>
+      def form_remote_tag(options = {}, &block)
         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"
+        options[:html][:onsubmit] = 
+          (options[:html][:onsubmit] ? options[:html][:onsubmit] + "; " : "") + 
+          "#{remote_function(options)}; return false;"
 
-        tag("form", options[:html], true)
+        form_tag(options[:html].delete(:action) || url_for(options[:url]), options[:html], &block)
       end
 
       # Works like form_remote_tag, but uses form_for semantics.
@@ -194,81 +204,6 @@ module ActionView
         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.
-      #
-      # 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).
-      #
-      # See also JavaScriptGenerator and update_page.
-      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.
@@ -289,7 +224,7 @@ module ActionView
         javascript_options = options_for_ajax(options)
 
         update = ''
-        if options[:update] and options[:update].is_a?Hash
+        if options[:update] && options[:update].is_a?(Hash)
           update  = []
           update << "success:'#{options[:update][:success]}'" if options[:update][:success]
           update << "failure:'#{options[:update][:failure]}'" if options[:update][:failure]
@@ -303,7 +238,7 @@ module ActionView
           "new Ajax.Updater(#{update}, "
 
         url_options = options[:url]
-        url_options = url_options.merge(:escape => false) if url_options.is_a? Hash
+        url_options = url_options.merge(:escape => false) if url_options.is_a?(Hash)
         function << "'#{url_for(url_options)}'"
         function << ", #{javascript_options})"
 
@@ -438,7 +373,7 @@ module ActionView
               if ActionView::Base.debug_rjs
                 source = javascript.dup
                 javascript.replace "try {\n#{source}\n} catch (e) "
-                javascript << "{ alert('RJS error:\\n\\n' + e.toString()); alert('#{source.gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }}'); throw e }"
+                javascript << "{ alert('RJS error:\\n\\n' + e.toString()); alert('#{source.gsub('\\','\0\0').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }}'); throw e }"
               end
             end
           end
@@ -453,6 +388,12 @@ module ActionView
             JavaScriptElementProxy.new(self, id)
           end
           
+          # Returns an object whose <tt>#to_json</tt> evaluates to +code+. Use this to pass a literal JavaScript 
+          # expression as an argument to another JavaScriptGenerator method.
+          def literal(code)
+            ActiveSupport::JSON::Variable.new(code.to_s)
+          end
+          
           # Returns a collection reference by finding it through a CSS +pattern+ in the DOM. This collection can then be
           # used for further method calls. Examples:
           #
@@ -526,7 +467,7 @@ module ActionView
           #
           #   # Replace the DOM element having ID 'person-45' with the
           #   # 'person' partial for the appropriate object.
-          #   replace_html 'person-45', :partial => 'person', :object => @person
+          #   replace 'person-45', :partial => 'person', :object => @person
           #
           # This allows the same partial that is used for the +insert_html+ to
           # be also used for the input to +replace+ without resorting to
@@ -550,22 +491,22 @@ module ActionView
           
           # Removes the DOM elements with the given +ids+ from the page.
           def remove(*ids)
-            record "#{javascript_object_for(ids)}.each(Element.remove)"
+            loop_on_multiple_args 'Element.remove', ids
           end
           
           # Shows hidden DOM elements with the given +ids+.
           def show(*ids)
-            call 'Element.show', *ids
+            loop_on_multiple_args 'Element.show', ids
           end
           
           # Hides the visible DOM elements with the given +ids+.
           def hide(*ids)
-            call 'Element.hide', *ids
+            loop_on_multiple_args 'Element.hide', ids           
           end
           
           # Toggles the visibility of the DOM elements with the given +ids+.
           def toggle(*ids)
-            call 'Element.toggle', *ids
+            loop_on_multiple_args 'Element.toggle', ids            
           end
           
           # Displays an alert dialog with the given +message+.
@@ -573,16 +514,18 @@ module ActionView
             call 'alert', message
           end
           
-          # Redirects the browser to the given +location+, in the same form as
-          # +url_for+.
+          # Redirects the browser to the given +location+, in the same form as +url_for+.
           def redirect_to(location)
             assign 'window.location.href', @context.url_for(location)
           end
           
-          # Calls the JavaScript +function+, optionally with the given 
-          # +arguments+.
-          def call(function, *arguments)
-            record "#{function}(#{arguments_for_call(arguments)})"
+          # Calls the JavaScript +function+, optionally with the given +arguments+.
+          #
+          # If a block is given, the block will be passed to a new JavaScriptGenerator;
+          # the resulting JavaScript code will then be wrapped inside <tt>function() { ... }</tt> 
+          # and passed as the called function's final argument.
+          def call(function, *arguments, &block)
+            record "#{function}(#{arguments_for_call(arguments, block)})"
           end
           
           # Assigns the JavaScript +variable+ the given +value+.
@@ -633,12 +576,18 @@ module ActionView
           end
           
           private
+            def loop_on_multiple_args(method, ids)
+              record(ids.size>1 ? 
+                "#{javascript_object_for(ids)}.each(#{method})" : 
+                "#{method}(#{ids.first.to_json})")
+            end
+              
             def page
               self
             end
           
             def record(line)
-              returning line = "#{line.to_s.chomp.gsub /\;$/, ''};" do
+              returning line = "#{line.to_s.chomp.gsub(/\;\z/, '')};" do
                 self << line
               end
             end
@@ -653,10 +602,16 @@ module ActionView
               object.respond_to?(:to_json) ? object.to_json : object.inspect
             end
           
-            def arguments_for_call(arguments)
+            def arguments_for_call(arguments, block = nil)
+              arguments << block_to_function(block) if block
               arguments.map { |argument| javascript_object_for(argument) }.join ', '
             end
             
+            def block_to_function(block)
+              generator = self.class.new(@context, &block)
+              literal("function() { #{generator.to_s} }")
+            end  
+
             def method_missing(method, *arguments)
               JavaScriptProxy.new(self, method.to_s.camelize)
             end
@@ -673,8 +628,11 @@ module ActionView
       # Works like update_page but wraps the generated JavaScript in a <script>
       # tag. Use this to include generated JavaScript in an ERb template.
       # See JavaScriptGenerator for more information.
-      def update_page_tag(&block)
-        javascript_tag update_page(&block)
+      #
+      # +html_options+ may be a hash of <script> attributes to be passed
+      # to ActionView::Helpers::JavaScriptHelper#javascript_tag.  
+      def update_page_tag(html_options = {}, &block)
+        javascript_tag update_page(&block), html_options
       end
 
     protected
@@ -738,16 +696,16 @@ module ActionView
       end
 
       private
-        def method_missing(method, *arguments)
+        def method_missing(method, *arguments, &block)
           if method.to_s =~ /(.*)=$/
             assign($1, arguments.first)
           else
-            call("#{method.to_s.camelize(:lower)}", *arguments)
+            call("#{method.to_s.camelize(:lower)}", *arguments, &block)
           end
         end
       
-        def call(function, *arguments)
-          append_to_function_chain!("#{function}(#{@generator.send(:arguments_for_call, arguments)})")
+        def call(function, *arguments, &block)
+          append_to_function_chain!("#{function}(#{@generator.send(:arguments_for_call, arguments, block)})")
           self
         end
 
@@ -756,7 +714,7 @@ module ActionView
         end
         
         def function_chain
-          @function_chain ||= @generator.instance_variable_get("@lines")
+          @function_chain ||= @generator.instance_variable_get(:@lines)
         end
         
         def append_to_function_chain!(call)
@@ -771,6 +729,21 @@ module ActionView
         super(generator, "$(#{id.to_json})")
       end
       
+      # Allows access of element attributes through +attribute+. Examples:
+      #
+      #   page['foo']['style']                  # => $('foo').style;
+      #   page['foo']['style']['color']         # => $('blank_slate').style.color;
+      #   page['foo']['style']['color'] = 'red' # => $('blank_slate').style.color = 'red';
+      #   page['foo']['style'].color = 'red'    # => $('blank_slate').style.color = 'red';
+      def [](attribute)
+        append_to_function_chain!(attribute)
+        self
+      end
+      
+      def []=(variable, value)
+        assign(variable, value)
+      end
+      
       def replace_html(*options_for_render)
         call 'update', @generator.send(:render, *options_for_render)
       end
@@ -779,8 +752,8 @@ module ActionView
         call 'replace', @generator.send(:render, *options_for_render)
       end
       
-      def reload
-        replace :partial => @id.to_s
+      def reload(options_for_replace = {})
+        replace(options_for_replace.merge({ :partial => @id.to_s }))
       end
       
     end
@@ -811,8 +784,8 @@ module ActionView
     end
 
     class JavaScriptCollectionProxy < JavaScriptProxy #:nodoc:
-      ENUMERABLE_METHODS_WITH_RETURN = [:all, :any, :collect, :map, :detect, :find, :find_all, :select, :max, :min, :partition, :reject, :sort_by]
-      ENUMERABLE_METHODS = ENUMERABLE_METHODS_WITH_RETURN + [:each]
+      ENUMERABLE_METHODS_WITH_RETURN = [:all, :any, :collect, :map, :detect, :find, :find_all, :select, :max, :min, :partition, :reject, :sort_by] unless defined? ENUMERABLE_METHODS_WITH_RETURN
+      ENUMERABLE_METHODS = ENUMERABLE_METHODS_WITH_RETURN + [:each] unless defined? ENUMERABLE_METHODS
       attr_reader :generator
       delegate :arguments_for_call, :to => :generator
 
@@ -899,3 +872,5 @@ module ActionView
     end
   end
 end
+
+require File.dirname(__FILE__) + '/javascript_helper'