[PATCH] send_ajax response helper

requires patch in #940, as the html text may contain newlines.

Here's a first stab at a helper function:

      def ajax_update(target, &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] = ''

        text = escape_javascript(data)
        "$('#{target}').innerHTML = '#{text}'"

      end

To use this, place something like this in a partial or a template (make sure no layout is used):

<% @result = ajax_update("targetdiv") do  %>
"That's all folks!"
I just replaced your <b>targetdiv</b> with this text. How do you like that?
<% end %>
<%= @result %>

and to trigger it, make a page that actually has a div with an id of "targetdiv" and use link_to_remote:

<div id="targetdiv">blah</div>
<div>
<%= link_to_remote "deletefirst",
          :url => {
            :controller =>"message",
            :action=>"deletefirst"
          },
          :complete => 'eval(request.responseText)'
%>
</div>

Again, the beauty of this is that the server sepcifies were the response goes, not the client; if there was an error, the server could update the flash area or something.

Still todo: insert, append, delete... should be similar to code already written.

again: don't forget patch in #940

This supports more functions, and raises an argument error if called with an invalid argument

      def send_ajax(target, action = :update, &block)
        
        if block then
          # execute the block=  
          # this code stolen from the capture helper
          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] = ''
          text = escape_javascript(data)
        end
          
        # Some discussion has been taking place on 
        # http://wiki.rubyonrails.com/rails/show/Ajax%20Discussion
        # as to whether this is the fastest way to manipulate the DOM
        # At the moment, it appears the safest and most expedient
        case action
          when :replace            
            "$('#{target}').innerHTML = '#{text}'"
          when :insert
            "$('#{target}').innerHTML = '#{text}' + $('#{target}').innerHTML"         
          when :append
            "$('#{target}').innerHTML += '#{text}'"
          when :empty
            "$('#{target}').innerHTML = ''"
          when :delete
            "$('#{target}').parentNode.removeChild($('#{target}'))"
          else
            raise ArgumentError
        end
      
      end

one could add some more descriptive text to the raise ArgumentError line ;)

A more verbose argument error:

raise ArgumentError, "second parameter must be one of replace, insert, append, empty or delete"

Makes use of new position code and better errors

      # helper function to send a javascript command to the client.
      # options hash should have:
      # :action => (:insert, :replace, :delete, :empty)
      # :target => DOM element. (string name)
      # :position => (:before, :top, :bottom, :after) 
      #   postion is only used in the insert routines
      # pass in a block of captured erb html for functions that make sense to do so.
      def send_ajax(options, &block)
        
        if block then
          # execute the block=  
          # this code stolen from the capture helper
          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] = ''
          text = escape_javascript(data)
        end
          
        # Some discussion has been taking place on 
        # http://wiki.rubyonrails.com/rails/show/Ajax%20Discussion
        # as to whether this is the fastest way to manipulate the DOM
        # At the moment, it appears the safest and most expedient
        case options[:action]
          when :insert
            case options[:position]
              when :before
                "Insert.before('#{options[:target]}', '#{text}')"
              when :top
                "Insert.top('#{options[:target]}', '#{text}')"
              when :bottom
                "Insert.bottom('#{options[:target]}', '#{text}')"
              when :after
                "Insert.after('#{options[:target]}', '#{text}')"
              else
                raise ArgumentError, "Invalid position, choose one of :before, :top, :bottom, :after"
            end
          when :replace
            "$('#{target}').innerHTML = '#{text}'"         
          when :empty
            "$('#{target}').innerHTML = ''"
          when :delete
            "$('#{target}').parentNode.removeChild($('#{options[:target]}'))"
          else
            raise ArgumentError, "Invalid action, choos one of :insert, :replace, :delete, :empty"
        end
      
      end

note: this code work in revision 1011, but the OO'ified Insertion lib broke this code.

Updated to work with OO'ified Insertion lib.

(I needed to add a "new" to it to create the object)

      # helper function to send a javascript command to the client.
      # options hash should have:
      # :action => (:insert, :replace, :delete, :empty)
      # :target => DOM element. (string name)
      # :position => (:before, :top, :bottom, :after) 
      #   postion is only used in the insert routines
      # pass in a block of captured erb html for functions that make sense to do so.
      def send_ajax(options, &block)
        
        if block then
          # execute the block=  
          # this code stolen from the capture helper
          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] = ''
          text = escape_javascript(data)
        end
          
        case options[:action]
          when :insert
            case options[:position]
              when :before
                "new Insertion.Before('#{options[:target]}', '#{text}')"
              when :top
                "new Insertion.Top('#{options[:target]}', '#{text}')"
              when :bottom
                "new Insertion.Bottom('#{options[:target]}', '#{text}')"
              when :after
                "new Insertion.After('#{options[:target]}', '#{text}')"
              else
                raise ArgumentError, "Invalid position, choose one of :before, :top, :bottom, :after"
            end
          when :replace
            "$('#{target}').innerHTML = '#{text}'"         
          when :empty
            "$('#{target}').innerHTML = ''"
          when :delete
            "$('#{target}').parentNode.removeChild($('#{options[:target]}'))"
          else
            raise ArgumentError, "Invalid action, choos one of :insert, :replace, :delete, :empty"
        end
      
      end

apply to: actionpack/lib/action_view/helpers/javascript_helper.rb

typo in docs fixed. Use this patch instead of previous

Something like Ruby ParseTree (rubyforge) might make the following feasible: - write just Ruby code including for the DOM - use some Ruby-browser bridge to see the DOM (e.g. COM/IE6) - debug just Ruby code - use ParseTree to transform into Javascript

This will probably mean - some subset of Ruby (classes, methods, blocks should be fine) that can be mapped reasonably to Javascript - a fair chunk of work up front on the browser bridge

But the result might be worth it.

Possibly interesting idea, but not applicable to this ticket. A better place to discuss it would be http://wiki.rubyonrails.com/rails/show/Ajax%20Discussion

added formfill action which can fill in all the fields for a given AR object.

fixed typo with :target variables.

Slightly expanded version to use it in helpers, adds an optional "text" parameter

Helper module for the controller. Provides #render_ajax and #render_ajax_to_string .

added JS check to see if form object exists before accessing the value attribute

Mortonda: please have a look at "upload_progress_send_ajax.rb", and incorporate this change in your code (simple but very useful addition...)! thx

here's another way to call send_ajax:

<% concat(send_ajax( ......) do %>
html stuff
<% end, binding) %>