prototype-rails 0.1

data/lib/action_view/helpers/scriptaculous_helper.rb

@@ -0,0 +1,263 @@
+require 'action_view/helpers/javascript_helper'
+require 'active_support/json'
+
+module ActionView
+  # = Action View Scriptaculous Helpers
+  module Helpers
+    # Provides a set of helpers for calling Scriptaculous[http://script.aculo.us/]
+    # JavaScript functions, including those which create Ajax controls and visual
+    # effects.
+    #
+    # To be able to use these helpers, you must include the Prototype
+    # JavaScript framework and the Scriptaculous JavaScript library in your
+    # pages. See the documentation for ActionView::Helpers::JavaScriptHelper
+    # for more information on including the necessary JavaScript.
+    #
+    # The Scriptaculous helpers' behavior can be tweaked with various options.
+    #
+    # See the documentation at http://script.aculo.us for more information on
+    # using these helpers in your application.
+    module ScriptaculousHelper
+      TOGGLE_EFFECTS = [:toggle_appear, :toggle_slide, :toggle_blind]
+
+      # Returns a JavaScript snippet to be used on the Ajax callbacks for
+      # starting visual effects.
+      #
+      # 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_receiving_element (...), :loading => visual_effect(:fade) %>
+      #
+      # This would fade the element that was dropped on the drop receiving
+      # element.
+      #
+      # For toggling visual effects, you can use <tt>:toggle_appear</tt>, <tt>:toggle_slide</tt>, and
+      # <tt>:toggle_blind</tt> which will alternate between appear/fade, slidedown/slideup, and
+      # blinddown/blindup respectively.
+      #
+      # 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 ? ActiveSupport::JSON.encode(element_id) : "element"
+
+        js_options[:queue] = if js_options[:queue].is_a?(Hash)
+          '{' + js_options[:queue].map {|k, v| k == :limit ? "#{k}:#{v}" : "#{k}:'#{v}'" }.join(',') + '}'
+        elsif js_options[:queue]
+          "'#{js_options[:queue]}'"
+        end if js_options[:queue]
+
+        [:endcolor, :direction, :startcolor, :scaleMode, :restorecolor].each do |option|
+          js_options[option] = "'#{js_options[option]}'" if js_options[option]
+        end
+
+        if TOGGLE_EFFECTS.include? name.to_sym
+          "Effect.toggle(#{element},'#{name.to_s.gsub(/^toggle_/,'')}',#{options_for_javascript(js_options)});"
+        else
+          "new Effect.#{name.to_s.camelize}(#{element},#{options_for_javascript(js_options)});"
+        end
+      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.
+      #
+      # 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.
+      #
+      # Important: For this to work, the sortable elements must have id
+      # attributes in the form "string_identifier". For example, "item_1". Only
+      # the identifier part of the id attribute will be serialized.
+      #
+      # Additional +options+ are:
+      #
+      # * <tt>:format</tt> - A regular expression to determine what to send as the
+      #   serialized id to the server (the default is <tt>/^[^_]*_(.*)$/</tt>).
+      #
+      # * <tt>:constraint</tt> - Whether to constrain the dragging to either
+      #   <tt>:horizontal</tt> or <tt>:vertical</tt> (or false to make it unconstrained).
+      #
+      # * <tt>:overlap</tt> - Calculate the item overlap in the <tt>:horizontal</tt>
+      #   or <tt>:vertical</tt> direction.
+      #
+      # * <tt>:tag</tt> - Which children of the container element to treat as
+      #   sortable (default is <tt>li</tt>).
+      #
+      # * <tt>:containment</tt> - Takes an element or array of elements to treat as
+      #   potential drop targets (defaults to the original target element).
+      #
+      # * <tt>:only</tt> - A CSS class name or array of class names used to filter
+      #   out child elements as candidates.
+      #
+      # * <tt>:scroll</tt> - Determines whether to scroll the list during drag
+      #   operations if the list runs past the visual border.
+      #
+      # * <tt>:tree</tt> - Determines whether to treat nested lists as part of the
+      #   main sortable list. This means that you can create multi-layer lists,
+      #   and not only sort items at the same level, but drag and sort items
+      #   between levels.
+      #
+      # * <tt>:hoverclass</tt> - If set, the Droppable will have this additional CSS class
+      #   when an accepted Draggable is hovered over it.
+      #
+      # * <tt>:handle</tt> - Sets whether the element should only be draggable by an
+      #   embedded handle. The value may be a string referencing a CSS class value
+      #   (as of script.aculo.us V1.5). The first child/grandchild/etc. element
+      #   found within the element that has this CSS class value will be used as
+      #   the handle.
+      #
+      # * <tt>:ghosting</tt> - Clones the element and drags the clone, leaving
+      #   the original in place until the clone is dropped (default is <tt>false</tt>).
+      #
+      # * <tt>:dropOnEmpty</tt> - If true the Sortable container will be made into
+      #   a Droppable, that can receive a Draggable (as according to the containment
+      #   rules) as a child element when there are no more elements inside (default
+      #   is <tt>false</tt>).
+      #
+      # * <tt>:onChange</tt> - Called whenever the sort order changes while dragging. When
+      #   dragging from one Sortable to another, the callback is called once on each
+      #   Sortable. Gets the affected element as its parameter.
+      #
+      # * <tt>:onUpdate</tt> - Called when the drag ends and the Sortable's order is
+      #   changed in any way. When dragging from one Sortable to another, the callback
+      #   is called once on each Sortable. Gets the container as its parameter.
+      #
+      # See http://script.aculo.us for more documentation.
+      def sortable_element(element_id, options = {})
+        javascript_tag(sortable_element_js(element_id, options).chop!)
+      end
+
+      def sortable_element_js(element_id, options = {}) #:nodoc:
+        options[:with]     ||= "Sortable.serialize(#{ActiveSupport::JSON.encode(element_id)})"
+        options[:onUpdate] ||= "function(){" + remote_function(options) + "}"
+        options.delete_if { |key, value| PrototypeHelper::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]
+
+        %(Sortable.create(#{ActiveSupport::JSON.encode(element_id)}, #{options_for_javascript(options)});)
+      end
+
+      # Makes the element with the DOM ID specified by +element_id+ draggable.
+      #
+      # 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(draggable_element_js(element_id, options).chop!)
+      end
+
+      def draggable_element_js(element_id, options = {}) #:nodoc:
+        %(new Draggable(#{ActiveSupport::JSON.encode(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.
+      #
+      # 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.
+      #
+      # Some of these +options+ include:
+      # * <tt>:accept</tt> - Set this to a string or an array of strings describing the
+      #   allowable CSS classes that the +draggable_element+ must have in order
+      #   to be accepted by this +drop_receiving_element+.
+      #
+      # * <tt>:confirm</tt> - Adds a confirmation dialog. Example:
+      #
+      #     :confirm => "Are you sure you want to do this?"
+      #
+      # * <tt>:hoverclass</tt> - If set, the +drop_receiving_element+ will have
+      #   this additional CSS class when an accepted +draggable_element+ is
+      #   hovered over it.
+      #
+      # * <tt>:onDrop</tt> - Called when a +draggable_element+ is dropped onto
+      #   this element. Override this callback with a JavaScript expression to
+      #   change the default drop behaviour. Example:
+      #
+      #     :onDrop => "function(draggable_element, droppable_element, event) { alert('I like bananas') }"
+      #
+      #   This callback gets three parameters: The Draggable element, the Droppable
+      #   element and the Event object. You can extract additional information about
+      #   the drop - like if the Ctrl or Shift keys were pressed - from the Event object.
+      #
+      # * <tt>:with</tt> - A JavaScript expression specifying the parameters for
+      #   the XMLHttpRequest. Any expressions should return a valid URL query string.
+      def drop_receiving_element(element_id, options = {})
+        javascript_tag(drop_receiving_element_js(element_id, options).chop!)
+      end
+
+      def drop_receiving_element_js(element_id, options = {}) #:nodoc:
+        options[:with]     ||= "'id=' + encodeURIComponent(element.id)"
+        options[:onDrop]   ||= "function(element){" + remote_function(options) + "}"
+        options.delete_if { |key, value| PrototypeHelper::AJAX_OPTIONS.include?(key) }
+
+        options[:accept] = array_or_string_for_javascript(options[:accept]) if options[:accept]
+        options[:hoverclass] = "'#{options[:hoverclass]}'" if options[:hoverclass]
+
+        # Confirmation happens during the onDrop callback, so it can be removed from the options
+        options.delete(:confirm) if options[:confirm]
+
+        %(Droppables.add(#{ActiveSupport::JSON.encode(element_id)}, #{options_for_javascript(options)});)
+      end
+
+      protected
+        def array_or_string_for_javascript(option)
+          if option.kind_of?(Array)
+            "['#{option.join('\',\'')}']"
+          elsif !option.nil?
+            "'#{option}'"
+          end
+        end
+    end
+
+    module PrototypeHelper
+      class JavaScriptGenerator
+        module GeneratorMethods
+          # Starts a script.aculo.us visual effect. See
+          # ActionView::Helpers::ScriptaculousHelper for more information.
+          def visual_effect(name, id = nil, options = {})
+            record @context.send(:visual_effect, name, id, options)
+          end
+
+          # Creates a script.aculo.us sortable element. Useful
+          # to recreate sortable elements after items get added
+          # or deleted.
+          # See ActionView::Helpers::ScriptaculousHelper for more information.
+          def sortable(id, options = {})
+            record @context.send(:sortable_element_js, id, options)
+          end
+
+          # Creates a script.aculo.us draggable element.
+          # See ActionView::Helpers::ScriptaculousHelper for more information.
+          def draggable(id, options = {})
+            record @context.send(:draggable_element_js, id, options)
+          end
+
+          # Creates a script.aculo.us drop receiving element.
+          # See ActionView::Helpers::ScriptaculousHelper for more information.
+          def drop_receiving(id, options = {})
+            record @context.send(:drop_receiving_element_js, id, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_view/template/handlers/rjs.rb

@@ -0,0 +1,14 @@
+module ActionView
+  module Template::Handlers
+    class RJS
+      # Default format used by RJS.
+      class_attribute :default_format
+      self.default_format = Mime::JS
+
+      def call(template)
+        "update_page do |page|;#{template.source}\nend"
+      end
+    end
+  end
+end
+

data/lib/prototype-rails.rb

@@ -0,0 +1,17 @@
+require 'rails'
+require 'active_support'
+
+module PrototypeRails
+  class Engine < Rails::Engine
+    initializer 'prototype-rails.initialize' do
+      ActiveSupport.on_load(:action_controller) do
+        require 'prototype-rails/on_load_action_controller'
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        require 'prototype-rails/on_load_action_view'
+      end
+    end
+  end
+end
+

data/lib/prototype-rails/javascript_helper.rb

@@ -0,0 +1,65 @@
+require 'action_view/helpers/javascript_helper'
+
+ActionView::Helpers::JavaScriptHelper.module_eval do
+  include ActionView::Helpers::PrototypeHelper
+
+  # Returns a button with the given +name+ text that'll trigger a JavaScript +function+ using the
+  # onclick handler.
+  #
+  # The first argument +name+ is used as the button's value or display text.
+  #
+  # The next arguments are optional and may include the javascript function definition and a hash of html_options.
+  #
+  # The +function+ argument can be omitted in favor of an +update_page+
+  # block, which evaluates to a string when the template is rendered
+  # (instead of making an Ajax request first).
+  #
+  # The +html_options+ will accept a hash of html attributes for the link tag. Some examples are :class => "nav_button", :id => "articles_nav_button"
+  #
+  # Note: if you choose to specify the javascript function in a block, but would like to pass html_options, set the +function+ parameter to nil
+  #
+  # Examples:
+  #   button_to_function "Greeting", "alert('Hello world!')"
+  #   button_to_function "Delete", "if (confirm('Really?')) do_delete()"
+  #   button_to_function "Details" do |page|
+  #     page[:details].visual_effect :toggle_slide
+  #   end
+  #   button_to_function "Details", :class => "details_button" do |page|
+  #     page[:details].visual_effect :toggle_slide
+  #   end
+  def button_to_function(name, *args, &block)
+    html_options = args.extract_options!.symbolize_keys
+
+    function = block_given? ? update_page(&block) : args[0] || ''
+    onclick = "#{"#{html_options[:onclick]}; " if html_options[:onclick]}#{function};"
+
+    tag(:input, html_options.merge(:type => 'button', :value => name, :onclick => onclick))
+  end
+
+  #   link_to_function("Show me more", nil, :id => "more_link") do |page|
+  #     page[:details].visual_effect  :toggle_blind
+  #     page[:more_link].replace_html "Show me less"
+  #   end
+  #     Produces:
+  #       <a href="#" id="more_link" onclick="try {
+  #         $(&quot;details&quot;).visualEffect(&quot;toggle_blind&quot;);
+  #         $(&quot;more_link&quot;).update(&quot;Show me less&quot;);
+  #       }
+  #       catch (e) {
+  #         alert('RJS error:\n\n' + e.toString());
+  #         alert('$(\&quot;details\&quot;).visualEffect(\&quot;toggle_blind\&quot;);
+  #         \n$(\&quot;more_link\&quot;).update(\&quot;Show me less\&quot;);');
+  #         throw e
+  #       };
+  #       return false;">Show me more</a>
+  #
+  def link_to_function(name, *args, &block)
+    html_options = args.extract_options!.symbolize_keys
+
+    function = block_given? ? update_page(&block) : args[0] || ''
+    onclick = "#{"#{html_options[:onclick]}; " if html_options[:onclick]}#{function}; return false;"
+    href = html_options[:href] || '#'
+
+    content_tag(:a, name, html_options.merge(:href => href, :onclick => onclick))
+  end
+end

data/lib/prototype-rails/on_load_action_controller.rb

@@ -0,0 +1,2 @@
+require 'prototype-rails/selector_assertions'
+require 'prototype-rails/renderers'

data/lib/prototype-rails/on_load_action_view.rb

@@ -0,0 +1,22 @@
+require 'action_view/helpers/prototype_helper'
+require 'action_view/helpers/scriptaculous_helper'
+require 'action_view/template/handlers/rjs'
+require 'prototype-rails/javascript_helper'
+require 'prototype-rails/rendering'
+
+ActionView::Base.class_eval do
+  cattr_accessor :debug_rjs
+  self.debug_rjs = false
+end
+
+ActionView::Base.class_eval do
+  include ActionView::Helpers::PrototypeHelper
+  include ActionView::Helpers::ScriptaculousHelper
+end
+
+ActionView::TestCase.class_eval do
+  include ActionView::Helpers::PrototypeHelper
+  include ActionView::Helpers::ScriptaculousHelper
+end
+
+ActionView::Template.register_template_handler :rjs, ActionView::Template::Handlers::RJS.new

data/lib/prototype-rails/renderers.rb

@@ -0,0 +1,12 @@
+require 'action_controller/metal/renderers'
+
+module ActionController
+  module Renderers
+    add :update do |proc, options|
+      view_context = self.view_context
+      generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(view_context, &proc)
+      self.content_type  = Mime::JS
+      self.response_body = generator.to_s
+    end
+  end
+end

data/lib/prototype-rails/rendering.rb

@@ -0,0 +1,13 @@
+require 'action_view/rendering'
+
+ActionView::Rendering.module_eval do
+  def render_with_update(options = {}, locals = {}, &block)
+    if options == :update
+      update_page(&block)
+    else
+      render_without_update(options, locals, &block)
+    end
+  end
+  
+  alias_method_chain :render, :update
+end

data/lib/prototype-rails/selector_assertions.rb

@@ -0,0 +1,208 @@
+require 'action_controller/vendor/html-scanner'
+require 'action_dispatch/testing/assertions/selector'
+
+#--
+# Copyright (c) 2006 Assaf Arkin (http://labnotes.org)
+# Under MIT and/or CC By license.
+#++
+
+ActionDispatch::Assertions::SelectorAssertions.module_eval do
+  # Selects content from the RJS response.
+  #
+  # === Narrowing down
+  #
+  # With no arguments, asserts that one or more elements are updated or
+  # inserted by RJS statements.
+  #
+  # Use the +id+ argument to narrow down the assertion to only statements
+  # that update or insert an element with that identifier.
+  #
+  # Use the first argument to narrow down assertions to only statements
+  # of that type. Possible values are <tt>:replace</tt>, <tt>:replace_html</tt>,
+  # <tt>:show</tt>, <tt>:hide</tt>, <tt>:toggle</tt>, <tt>:remove</tta>,
+  # <tt>:insert_html</tt> and <tt>:redirect</tt>.
+  #
+  # Use the argument <tt>:insert</tt> followed by an insertion position to narrow
+  # down the assertion to only statements that insert elements in that
+  # position. Possible values are <tt>:top</tt>, <tt>:bottom</tt>, <tt>:before</tt>
+  # and <tt>:after</tt>.
+  #
+  # Use the argument <tt>:redirect</tt> followed by a path to check that an statement
+  # which redirects to the specified path is generated.
+  #
+  # Using the <tt>:remove</tt> statement, you will be able to pass a block, but it will
+  # be ignored as there is no HTML passed for this statement.
+  #
+  # === Using blocks
+  #
+  # Without a block, +assert_select_rjs+ merely asserts that the response
+  # contains one or more RJS statements that replace or update content.
+  #
+  # With a block, +assert_select_rjs+ also selects all elements used in
+  # these statements and passes them to the block. Nested assertions are
+  # supported.
+  #
+  # Calling +assert_select_rjs+ with no arguments and using nested asserts
+  # asserts that the HTML content is returned by one or more RJS statements.
+  # Using +assert_select+ directly makes the same assertion on the content,
+  # but without distinguishing whether the content is returned in an HTML
+  # or JavaScript.
+  #
+  # ==== Examples
+  #
+  #   # Replacing the element foo.
+  #   # page.replace 'foo', ...
+  #   assert_select_rjs :replace, "foo"
+  #
+  #   # Replacing with the chained RJS proxy.
+  #   # page[:foo].replace ...
+  #   assert_select_rjs :chained_replace, 'foo'
+  #
+  #   # Inserting into the element bar, top position.
+  #   assert_select_rjs :insert, :top, "bar"
+  #
+  #   # Remove the element bar
+  #   assert_select_rjs :remove, "bar"
+  #
+  #   # Changing the element foo, with an image.
+  #   assert_select_rjs "foo" do
+  #     assert_select "img[src=/images/logo.gif""
+  #   end
+  #
+  #   # RJS inserts or updates a list with four items.
+  #   assert_select_rjs do
+  #     assert_select "ol>li", 4
+  #   end
+  #
+  #   # The same, but shorter.
+  #   assert_select "ol>li", 4
+  #
+  #   # Checking for a redirect.
+  #   assert_select_rjs :redirect, root_path
+  def assert_select_rjs(*args, &block)
+    rjs_type = args.first.is_a?(Symbol) ? args.shift : nil
+    id       = args.first.is_a?(String) ? args.shift : nil
+
+    # If the first argument is a symbol, it's the type of RJS statement we're looking
+    # for (update, replace, insertion, etc). Otherwise, we're looking for just about
+    # any RJS statement.
+    if rjs_type
+      if rjs_type == :insert
+        position  = args.shift
+        id = args.shift
+        insertion = "insert_#{position}".to_sym
+        raise ArgumentError, "Unknown RJS insertion type #{position}" unless RJS_STATEMENTS[insertion]
+        statement = "(#{RJS_STATEMENTS[insertion]})"
+      else
+        raise ArgumentError, "Unknown RJS statement type #{rjs_type}" unless RJS_STATEMENTS[rjs_type]
+        statement = "(#{RJS_STATEMENTS[rjs_type]})"
+      end
+    else
+      statement = "#{RJS_STATEMENTS[:any]}"
+    end
+
+    # Next argument we're looking for is the element identifier. If missing, we pick
+    # any element, otherwise we replace it in the statement.
+    pattern = Regexp.new(
+      id ? statement.gsub(RJS_ANY_ID, "\"#{id}\"") : statement
+    )
+
+    # Duplicate the body since the next step involves destroying it.
+    matches = nil
+    case rjs_type
+      when :remove, :show, :hide, :toggle
+        matches = @response.body.match(pattern)
+      else
+        @response.body.gsub(pattern) do |match|
+          html = unescape_rjs(match)
+          matches ||= []
+          matches.concat HTML::Document.new(html).root.children.select { |n| n.tag? }
+          ""
+        end
+    end
+
+    if matches
+      assert_block("") { true } # to count the assertion
+      if block_given? && !([:remove, :show, :hide, :toggle].include? rjs_type)
+        begin
+          @selected ||= nil
+          in_scope, @selected = @selected, matches
+          yield matches
+        ensure
+          @selected = in_scope
+        end
+      end
+      matches
+    else
+      # RJS statement not found.
+      case rjs_type
+        when :remove, :show, :hide, :toggle
+          flunk_message = "No RJS statement that #{rjs_type.to_s}s '#{id}' was rendered."
+        else
+          flunk_message = "No RJS statement that replaces or inserts HTML content."
+      end
+      flunk args.shift || flunk_message
+    end
+  end
+  
+  protected
+
+  RJS_PATTERN_HTML  = "\"((\\\\\"|[^\"])*)\""
+  RJS_ANY_ID        = "\"([^\"])*\""
+  RJS_STATEMENTS    = {
+    :chained_replace      => "\\$\\(#{RJS_ANY_ID}\\)\\.replace\\(#{RJS_PATTERN_HTML}\\)",
+    :chained_replace_html => "\\$\\(#{RJS_ANY_ID}\\)\\.update\\(#{RJS_PATTERN_HTML}\\)",
+    :replace_html         => "Element\\.update\\(#{RJS_ANY_ID}, #{RJS_PATTERN_HTML}\\)",
+    :replace              => "Element\\.replace\\(#{RJS_ANY_ID}, #{RJS_PATTERN_HTML}\\)",
+    :redirect             => "window.location.href = #{RJS_ANY_ID}"
+  }
+  [:remove, :show, :hide, :toggle].each do |action|
+    RJS_STATEMENTS[action] = "Element\\.#{action}\\(#{RJS_ANY_ID}\\)"
+  end
+  RJS_INSERTIONS = ["top", "bottom", "before", "after"]
+  RJS_INSERTIONS.each do |insertion|
+    RJS_STATEMENTS["insert_#{insertion}".to_sym] = "Element.insert\\(#{RJS_ANY_ID}, \\{ #{insertion}: #{RJS_PATTERN_HTML} \\}\\)"
+  end
+  RJS_STATEMENTS[:insert_html] = "Element.insert\\(#{RJS_ANY_ID}, \\{ (#{RJS_INSERTIONS.join('|')}): #{RJS_PATTERN_HTML} \\}\\)"
+  RJS_STATEMENTS[:any] = Regexp.new("(#{RJS_STATEMENTS.values.join('|')})")
+  RJS_PATTERN_UNICODE_ESCAPED_CHAR = /\\u([0-9a-zA-Z]{4})/
+
+  # +assert_select+ and +css_select+ call this to obtain the content in the HTML
+  # page, or from all the RJS statements, depending on the type of response.
+  def response_from_page_with_rjs
+    content_type = @response.content_type
+
+    if content_type && Mime::JS =~ content_type
+      body = @response.body.dup
+      root = HTML::Node.new(nil)
+
+      while true
+        next if body.sub!(RJS_STATEMENTS[:any]) do |match|
+          html = unescape_rjs(match)
+          matches = HTML::Document.new(html).root.children.select { |n| n.tag? }
+          root.children.concat matches
+          ""
+        end
+        break
+      end
+
+      root
+    else
+      response_from_page_without_rjs
+    end
+  end
+  alias_method_chain :response_from_page, :rjs
+
+  # Unescapes a RJS string.
+  def unescape_rjs(rjs_string)
+    # RJS encodes double quotes and line breaks.
+    unescaped= rjs_string.gsub('\"', '"')
+    unescaped.gsub!(/\\\//, '/')
+    unescaped.gsub!('\n', "\n")
+    unescaped.gsub!('\076', '>')
+    unescaped.gsub!('\074', '<')
+    # RJS encodes non-ascii characters.
+    unescaped.gsub!(RJS_PATTERN_UNICODE_ESCAPED_CHAR) {|u| [$1.hex].pack('U*')}
+    unescaped
+  end
+end