Module: ScopedSearch::RailsHelper

Defined in:
lib/scoped_search/rails_helper.rb

Instance Method Summary collapse

Instance Method Details



180
181
182
183
184
# File 'lib/scoped_search/rails_helper.rb', line 180

def a_link(name, href, html_options)
  tag_options = tag_options(html_options)
  link = "<a href=\"#{href}\"#{tag_options}>#{name}</a>"
  return link.respond_to?(:html_safe) ? link.html_safe : link
end

#auto_complete_clear_value_button(field_id) ⇒ Object



175
176
177
178
# File 'lib/scoped_search/rails_helper.rb', line 175

def auto_complete_clear_value_button(field_id)
  html_options = {:tabindex => '-1',:class=>"auto_complete_clear",:title =>'Clear Search', :onclick=>"document.getElementById('#{field_id}').value = '';"}
  a_link("", "#", html_options)
end

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

Adds AJAX auto complete functionality to the text input field with the DOM ID specified by field_id.

Required options is:

:url

URL to call for auto completion results in url_for format.

Additional options are:

:update

Specifies the DOM ID of the element whose innerHTML should be updated with the auto complete entries returned by the AJAX request. Defaults to field_id + '_auto_complete'

:with

A JavaScript expression specifying the parameters for the XMLHttpRequest. This defaults to 'fieldname=value'.

:frequency

Determines the time to wait after the last keystroke for the AJAX request to be initiated.

:indicator

Specifies the DOM ID of an element which will be displayed while auto complete is running.

:tokens

A string or an array of strings containing separator tokens for tokenized incremental auto completion. Example: :tokens => ',' would allow multiple auto completion entries, separated by commas.

:min_chars

The minimum number of characters that should be in the input field before an Ajax call is made to the server.

:on_hide

A Javascript expression that is called when the auto completion div is hidden. The expression should take two variables: element and update. Element is a DOM element for the field, update is a DOM element for the div from which the innerHTML is replaced.

:on_show

Like on_hide, only now the expression is called then the div is shown.

:after_update_element

A Javascript expression that is called when the user has selected one of the proposed values. The expression should take two variables: element and value. Element is a DOM element for the field, value is the value selected by the user.

:select

Pick the class of the element from which the value for insertion should be extracted. If this is not specified, the entire element is used.

:method

Specifies the HTTP verb to use when the auto completion request is made. Defaults to POST.



100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
# File 'lib/scoped_search/rails_helper.rb', line 100

def auto_complete_field(field_id, options = {})
  function =  "var #{field_id}_auto_completer = new Ajax.Autocompleter("
  function << "'#{field_id}', "
  function << "'" + (options[:update] || "#{field_id}_auto_complete") + "', "
  function << "'#{url_for(options[:url])}'"

  js_options = {}
  js_options[:tokens] = array_or_string_for_javascript(options[:tokens])            if options[:tokens]
  js_options[:callback]   = "function(element, value) { return #{options[:with]} }" if options[:with]
  js_options[:indicator]  = "'#{options[:indicator]}'"                              if options[:indicator]
  js_options[:select]     = "'#{options[:select]}'"                                 if options[:select]
  js_options[:paramName]  = "'#{options[:param_name]}'"                             if options[:param_name]
  js_options[:frequency]  = "#{options[:frequency]}"                                if options[:frequency]
  js_options[:method]     = "'#{options[:method].to_s}'"                            if options[:method]

  { :after_update_element => :afterUpdateElement,
    :on_show => :onShow, :on_hide => :onHide, :min_chars => :minChars }.each do |k,v|
    js_options[v] = options[k] if options[k]
  end

  function << (', ' + options_for_javascript(js_options) + ')')

  javascript_tag(function)
end

#auto_complete_field_jquery(method, url, options = {}) ⇒ Object



125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
# File 'lib/scoped_search/rails_helper.rb', line 125

def auto_complete_field_jquery(method, url, options = {})
  function = <<-JAVASCRIPT
    $.widget( "custom.catcomplete", $.ui.autocomplete, {
      _renderMenu: function( ul, items ) {
        var self = this,
        currentCategory = "";
        $.each( items, function( index, item ) {
          if ( item.category != undefined && item.category != currentCategory ) {
            ul.append( "<li class='ui-autocomplete-category'>" + item.category + "</li>" );
            currentCategory = item.category;
          }
          if ( item.error != undefined ) {
            ul.append( "<li class='ui-autocomplete-error'>" + item.error + "</li>" );
          }
          if( item.completed != undefined ) {
            $( "<li></li>" ).data( "item.autocomplete", item )
		      .append( "<a>" + "<strong class='ui-autocomplete-completed'>" + item.completed + "</strong>" + item.part + "</a>" )
		      .appendTo( ul );
          } else {
            if(typeof(self._renderItemData) === "function") {
              self._renderItemData( ul, item );
            } else {
              self._renderItem( ul, item );
            }
          }
        });
      }
    });

    $("##{method}")
    .catcomplete({
	source: function( request, response ) {	$.getJSON( "#{url}", { #{method}: request.term }, response );	},
	minLength: #{options[:min_length] || 0},
    delay: #{options[:delay] || 200},
    select: function(event, ui) { $( this ).catcomplete( "search" , ui.item.value); },
    search: function(event, ui) { $(".auto_complete_clear").hide(); },
    open: function(event, ui) { $(".auto_complete_clear").show(); }
    });

    $("##{method}").bind( "focus", function( event ) {
      if( $( this )[0].value == "" ) {
			$( this ).catcomplete( "search" );
      }
	});

  JAVASCRIPT

  javascript_tag(function)
end

#auto_complete_field_tag(method, val, tag_options = {}, completion_options = {}) ⇒ Object

Wrapper for text_field with added AJAX auto completion functionality.

In your controller, you'll need to define an action called auto_complete_method to respond the AJAX calls,



200
201
202
203
204
205
206
207
# File 'lib/scoped_search/rails_helper.rb', line 200

def auto_complete_field_tag(method, val,tag_options = {}, completion_options = {})
  auto_completer_options = { :url => { :action => "auto_complete_#{method}" } }.update(completion_options)
  options = tag_options.merge(:class => "auto_complete_input " << tag_options[:class].to_s)
  text_field_tag(method, val,options) +
      auto_complete_clear_value_button(method) +
      ("div", "", :id => "#{method}_auto_complete", :class => "auto_complete") +
      auto_complete_field(method, auto_completer_options)
end

#auto_complete_field_tag_jquery(method, val, tag_options = {}, completion_options = {}) ⇒ Object

Wrapper for text_field with added JQuery auto completion functionality.

In your controller, you'll need to define an action called auto_complete_method to respond the JQuery calls,



213
214
215
216
217
218
# File 'lib/scoped_search/rails_helper.rb', line 213

def auto_complete_field_tag_jquery(method, val,tag_options = {}, completion_options = {})
  url = url_for(:action => "auto_complete_#{method}", :filter => completion_options[:filter])
  options = tag_options.merge(:class => "auto_complete_input " << tag_options[:class].to_s)
  text_field_tag(method, val, options) + auto_complete_clear_value_button(method) +
      auto_complete_field_jquery(method, url, completion_options)
end

#auto_complete_result(entries, phrase = nil) ⇒ Object

Use this method in your view to generate a return for the AJAX auto complete requests.

The auto_complete_result can of course also be called from a view belonging to the auto_complete action if you need to decorate it further.



190
191
192
193
194
# File 'lib/scoped_search/rails_helper.rb', line 190

def auto_complete_result(entries, phrase = nil)
  return unless entries
  items = entries.map { |entry| ("li", phrase ? highlight(entry, phrase) : h(entry)) }
  ("ul", items)
end

#sort(field, options = {}, html_options = {}) ⇒ Object

Creates a link that alternates between ascending and descending.

Examples:

sort @search, :by => :username
sort @search, :by => :created_at, :as => "Created"
sort @search, :by => :created_at, :default => "DESC"

This helper accepts the following options:

  • :by - the name of the named scope. This helper will prepend this value with “ascend_by_” and “descend_by_”

  • :as - the text used in the link, defaults to whatever is passed to :by

  • :default - default sorting order, DESC or ASC



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# File 'lib/scoped_search/rails_helper.rb', line 16

def sort(field, options = {}, html_options = {})

  unless options[:as]
    id           = field.to_s.downcase == "id"
    options[:as] = id ? field.to_s.upcase : field.to_s.humanize
  end

  ascend  = "#{field} ASC"
  descend = "#{field} DESC"
  selected = [ascend, descend].include?(params[:order])

  case params[:order]
    when ascend
      new_sort = descend
    when descend
      new_sort = ascend
    else
      new_sort = ["ASC", "DESC"].include?(options[:default]) ? "#{field} #{options[:default]}" : ascend
  end

  if selected
    css_classes = html_options[:class] ? html_options[:class].split(" ") : []
    if new_sort == ascend
      options[:as] = "&#9650;&nbsp;#{options[:as]}"
      css_classes << "ascending"
    else
      options[:as] = "&#9660;&nbsp;#{options[:as]}"
      css_classes << "descending"
    end
    html_options[:class] = css_classes.join(" ")
  end

  url_options = params.merge(:order => new_sort)

  options[:as] = raw(options[:as]) if defined?(RailsXss)

  a_link(options[:as], html_escape(url_for(url_options)),html_options)
end