Module: BivouacHelpers::JavaScriptView

Defined in:: lib/bivouac/helpers/view/goh/javascript.rb

Constant Summary collapse

CALLBACKS =

[ :uninitialized, :loading, :loaded, :interactive, :complete, :failure, :success ] + ('100'..'599').to_a

Instance Method Summary collapse

#escape_javascript(javascript) ⇒ Object
Escape carrier returns and single and double quotes for JavaScript segments.
#javascript_tag(content, options = {}) ⇒ Object
Returns a JavaScript tag with the block inside.
#link_to_function(name, *args, &block) ⇒ Object
Returns a link that will trigger a JavaScript function using the onclick handler and return false after the fact.
#link_to_remote(name, options = {}, html_options = {}) ⇒ Object
Returns a link to a remote action defined by options that's called in the background using XMLHttpRequest.
#observe_field(field_id, options = {}) ⇒ Object
Observes the field with the DOM ID specified by field_id and makes an Ajax call when its contents have changed.
#periodically_call_remote(options = {}) ⇒ Object
Periodically calls the specified url (options) every options seconds (default is 10).
#remote_function(options) ⇒ Object
Returns the JavaScript needed for a remote function.
#update_page(&block) ⇒ Object
Yields a JavaScriptGenerator and returns the generated JavaScript code.

#update_page_tag(options = {}, &block) ⇒ Object

Works like update_page but wraps the generated JavaScript in a

Escape carrier returns and single and double quotes for JavaScript segments.



202
203
204

# File 'lib/bivouac/helpers/view/goh/javascript.rb', line 202

def escape_javascript(javascript)
  (javascript || '').gsub('\\','\0\0').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
end

#javascript_tag(content, options = {}) ⇒ `Object`

Returns a JavaScript tag with the block inside. Example:

javascript_tag( "alert('Hello World!')", :defer => 'true' )

Returns:

# File 'lib/bivouac/helpers/view/goh/javascript.rb', line 218

def javascript_tag( content, options = {} )
  options[:type] = "text/javascript"
  script( options ) do
    "//<![CDATA[\n" + content + "\n//]]>\n"
  end
end

#link_to_function(name, *args, &block) ⇒ `Object`

Returns a link that will trigger a JavaScript function using the onclick handler and return false after the fact.

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).

Examples:

link_to_function "Greeting", "alert('Hello world!')"

Produces:

<a onclick="alert('Hello world!'); return false;" href="#">Greeting</a>

link_to_function(image_tag("delete"), "if (confirm('Really?')) do_delete()")

Produces:

<a onclick="if (confirm('Really?')) do_delete(); return false;" href="#">
<img src="/images/delete.png?" alt="Delete"/>
</a>

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>

# File 'lib/bivouac/helpers/view/goh/javascript.rb', line 273

def link_to_function( name, *args, &block )
  html_options = args.last.is_a?(Hash) ? args.pop : {}
  function = args[0] || ''
  
  function = update_page( &block ) if block_given?
  
  a( html_options.merge({ 
      :href => html_options[:href] || "#", 
      :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function}; return false;" 
    }) ) do
      name
  end
end

#link_to_remote(name, options = {}, html_options = {}) ⇒ `Object`

Returns a link to a remote action defined by options 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 options. Usually, the result would be a partial prepared by the controller.

Examples:

link_to_remote "Delete this post", :update => "posts", 
:url => R(Destroy, 1)
link_to_remote(image_tag("refresh"), :update => "emails", 
:url => R(ListEmails)

You can also specify a hash for options 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 => R(Destroy, 1)
:update => { :success => "posts", :failure => "error" }

Optionally, you can use the options parameter to influence how the target DOM element is updated. It must be one of :before, :top, :bottom, or :after.

To access the server response, use request.responseText, to find out the HTTP status, use request.status.

Example:

link_to_remote word,
:url => R(Undo, word_counter)
:complete => "undoRequestCompleted(request)"

The callbacks that may be specified are (in order):

:loading:: Called when the remote document is being loaded with data by the browser. :loaded:: Called when the browser has finished loading the remote document. :interactive:: Called when the user can interact with the remote document, even though it has not finished loading. :success:: Called when the XMLHttpRequest is completed, and the HTTP status code is in the 2XX range. :failure:: Called when the XMLHttpRequest is completed, and the HTTP status code is not in the 2XX range. :complete:: Called when the XMLHttpRequest is complete (fires after success/failure if they are present).

You can further refine :success and :failure by adding additional callbacks for specific status codes.

Example:

link_to_remote word,
:url => R(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 options = :synchronous.

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:

:confirm:: Adds confirmation dialog. :condition:: Perform remote request conditionally by this expression. Use this to describe browser-side conditions when request should not be initiated. :before:: Called before request is initiated. :after:: Called immediately after request was initiated and before :loading. :submit:: 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.



371
372
373

# File 'lib/bivouac/helpers/view/goh/javascript.rb', line 371

def link_to_remote(name, options = {}, html_options = {})  
  link_to_function(name, remote_function(options), html_options)
end

#observe_field(field_id, options = {}) ⇒ `Object`

Observes the field with the DOM ID specified by field_id and makes an Ajax call when its contents have changed.

Required options are either of: :url:: +url_for+-style options for the action to call when the field has changed. :function:: Instead of making a remote call to a URL, you can specify a function to be called instead.

Additional options are: :frequency:: 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. :update:: Specifies the DOM ID of the element whose innerHTML should be updated with the XMLHttpRequest response text. :with:: A JavaScript expression specifying the parameters for the XMLHttpRequest. This defaults to 'value', which in the evaluated context refers to the new field value. If you specify a string without a "=", it'll be extended to mean the form key that the value should be assigned to. So :with => "term" gives "'term'=value". If a "=" is present, no extension will happen. :on:: Specifies which event handler to observe. By default, it's set to "changed" for text fields and areas and "click" for radio buttons and checkboxes. With this, you can specify it instead to be "blur" or "focus" or any other event.

Additionally, you may specify any of the options documented in link_to_remote.

# File 'lib/bivouac/helpers/view/goh/javascript.rb', line 420

def observe_field(field_id, options = {})
  if options[:frequency] && options[:frequency] > 0
    build_observer('Form.Element.Observer', field_id, options)
  else
    build_observer('Form.Element.EventObserver', field_id, options)
  end
end

#periodically_call_remote(options = {}) ⇒ `Object`

Periodically calls the specified url (options) every options seconds (default is 10). Usually used to update a specified div (options) 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.

# File 'lib/bivouac/helpers/view/goh/javascript.rb', line 380

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

#remote_function(options) ⇒ `Object`

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 => R(Update), 
                                    :onSuccess => visual_effect( :highlight, 'my_element' ) 
                                  ) 
    ) do
option( "Hello", :value => 0 )
option( "World", :value => 1 )
end

# File 'lib/bivouac/helpers/view/goh/javascript.rb', line 442

def remote_function(options)
  javascript_options = options_for_ajax(options)

  update = ''
  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]
    update  = '{' + update.join(',') + '}'
  elsif options[:update]
    update << "'#{options[:update]}'"
  end

  function = update.empty? ? 
    "new Ajax.Request(" :
    "new Ajax.Updater(#{update}, "

  function << "'#{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
end

#update_page(&block) ⇒ `Object`

Yields a JavaScriptGenerator and returns the generated JavaScript code. Use this to update multiple elements on a page in an Ajax response. See JavaScriptGenerator for more information.



228
229
230

# File 'lib/bivouac/helpers/view/goh/javascript.rb', line 228

def update_page( &block )
  JavaScriptGenerator.new( self, &block ).to_s
end

#update_page_tag(options = {}, &block) ⇒ `Object`

Works like update_page but wraps the generated JavaScript in a

Module: BivouacHelpers::JavaScriptView

Constant Summary collapse

Instance Method Summary collapse

#javascript_tag(content, options = {}) ⇒ Object

#link_to_function(name, *args, &block) ⇒ Object

#link_to_remote(name, options = {}, html_options = {}) ⇒ Object

#observe_field(field_id, options = {}) ⇒ Object

#periodically_call_remote(options = {}) ⇒ Object

#remote_function(options) ⇒ Object

#update_page(&block) ⇒ Object

#update_page_tag(options = {}, &block) ⇒ Object

#javascript_tag(content, options = {}) ⇒ `Object`

#link_to_function(name, *args, &block) ⇒ `Object`

#link_to_remote(name, options = {}, html_options = {}) ⇒ `Object`

#observe_field(field_id, options = {}) ⇒ `Object`

#periodically_call_remote(options = {}) ⇒ `Object`

#remote_function(options) ⇒ `Object`

#update_page(&block) ⇒ `Object`

#update_page_tag(options = {}, &block) ⇒ `Object`