Module: ApplicationHelper

Extended by:
Forwardable
Includes:
GravatarHelper::PublicMethods, Redmine::I18n, Redmine::WikiFormatting::Macros::Definitions
Included in:
IssuesHelper, Redmine::Hook::ViewListener, TimelogHelper
Defined in:
lib/redmine/themes.rb,
app/helpers/application_helper.rb

Instance Method Summary (collapse)

Methods included from Redmine::I18n

#current_language, #day_name, #find_language, #format_date, #format_time, included, #l, #l_hours, #l_or_humanize, #ll, #month_name, #set_language_if_valid, #valid_languages

Methods included from Redmine::WikiFormatting::Macros::Definitions

#exec_macro, #extract_macro_options

Instance Method Details

- (Object) accesskey(s) 



320
321
322
 
# File 'app/helpers/application_helper.rb', line 320

def accesskey(s)
  Redmine::AccessKeys.key_for s
end

- (Object) authoring(created, author, options = {}) 



209
210
211
212
213
214
215
216
 
# File 'app/helpers/application_helper.rb', line 209

def authoring(created, author, options={})
  time_tag = @project.nil? ? content_tag('acronym', distance_of_time_in_words(Time.now, created), :title => format_time(created)) :
                             link_to(distance_of_time_in_words(Time.now, created), 
                                     {:controller => 'projects', :action => 'activity', :id => @project, :from => created.to_date},
                                     :title => format_time(created))
  author_tag = (author.is_a?(User) && !author.anonymous?) ? link_to(h(author), :controller => 'account', :action => 'show', :id => author) : h(author || 'Anonymous')
  l(options[:label] || :label_added_time_by, :author => author_tag, :age => time_tag)
end

- (Object) authorize_for(controller, action)

Return true if user is authorized for controller/action, otherwise false



36
37
38
 
# File 'app/helpers/application_helper.rb', line 36

def authorize_for(controller, action)
  User.current.allowed_to?({:controller => controller, :action => action}, @project)
end

- (Object) avatar(user, options = { })

Returns the avatar image tag for the given user if avatars are enabled user can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')



628
629
630
631
632
633
634
635
636
637
638
 
# File 'app/helpers/application_helper.rb', line 628

def avatar(user, options = { })
  if Setting.gravatar_enabled?
    email = nil
    if user.respond_to?(:mail)
      email = user.mail
    elsif user.to_s =~ %r{<(.+?)>}
      email = $1
    end
    return gravatar(email.to_s.downcase, options) unless email.blank? rescue nil
  end
end

- (Object) back_url_hidden_field_tag 



555
556
557
558
559
 
# File 'app/helpers/application_helper.rb', line 555

def back_url_hidden_field_tag
  back_url = params[:back_url] || request.env['HTTP_REFERER']
  back_url = CGI.unescape(back_url.to_s)
  hidden_field_tag('back_url', CGI.escape(back_url)) unless back_url.blank?
end

- (Object) breadcrumb(*args) 



276
277
278
279
 
# File 'app/helpers/application_helper.rb', line 276

def breadcrumb(*args)
  elements = args.flatten
  elements.any? ? content_tag('p', args.join(' &#187; ') + ' &#187; ', :class => 'breadcrumb') : nil
end

- (Object) calendar_for(field_id) 



598
599
600
601
602
 
# File 'app/helpers/application_helper.rb', line 598

def calendar_for(field_id)
  include_calendar_headers_tags
  image_tag("calendar.png", {:id => "#{field_id}_trigger",:class => "calendar-trigger"}) +
  javascript_tag("Calendar.setup({inputField : '#{field_id}', ifFormat : '%Y-%m-%d', button : '#{field_id}_trigger' });")
end

- (Object) check_all_links(form_name) 



561
562
563
564
565
 
# File 'app/helpers/application_helper.rb', line 561

def check_all_links(form_name)
  link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
  " | " +
  link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
end

- (Object) content_for(name, content = nil, &block) 



616
617
618
619
620
 
# File 'app/helpers/application_helper.rb', line 616

def content_for(name, content = nil, &block)
  @has_content ||= {}
  @has_content[name] = true
  super(name, content, &block)
end

- (Object) context_menu_link(name, url, options = {}) 



582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
 
# File 'app/helpers/application_helper.rb', line 582

def context_menu_link(name, url, options={})
  options[:class] ||= ''
  if options.delete(:selected)
    options[:class] << ' icon-checked disabled'
    options[:disabled] = true
  end
  if options.delete(:disabled)
    options.delete(:method)
    options.delete(:confirm)
    options.delete(:onclick)
    options[:class] << ' disabled'
    url = '#'
  end
  link_to name, url, options
end

- (Object) current_role 



31
32
33
 
# File 'app/helpers/application_helper.rb', line 31

def current_role
  @current_role ||= User.current.role_for_project(@project)
end

- (Object) due_date_distance_in_words(date) 



106
107
108
109
110
 
# File 'app/helpers/application_helper.rb', line 106

def due_date_distance_in_words(date)
  if date
    l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))
  end
end

- (Object) format_activity_day(date) 



98
99
100
 
# File 'app/helpers/application_helper.rb', line 98

def format_activity_day(date)
  date == Date.today ? l(:label_today).titleize : format_date(date)
end

- (Object) format_activity_description(text) 



102
103
104
 
# File 'app/helpers/application_helper.rb', line 102

def format_activity_description(text)
  h(truncate(text.to_s, :length => 120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')).gsub(/[\r\n]+/, "<br />")
end

- (Object) format_activity_title(text) 



94
95
96
 
# File 'app/helpers/application_helper.rb', line 94

def format_activity_title(text)
  h(truncate_single_line(text, :length => 100))
end

- (Boolean) has_content?(name)

Returns:

  • (Boolean) 


622
623
624
 
# File 'app/helpers/application_helper.rb', line 622

def has_content?(name)
  (@has_content && @has_content[name]) || false
end

- (Object) html_hours(text) 



205
206
207
 
# File 'app/helpers/application_helper.rb', line 205

def html_hours(text)
  text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>')
end

- (Object) html_title(*args) 



307
308
309
310
311
312
313
314
315
316
317
318
 
# File 'app/helpers/application_helper.rb', line 307

def html_title(*args)
  if args.empty?
    title = []
    title << @project.name if @project
    title += @html_title if @html_title
    title << Setting.app_title
    title.compact.join(' - ')
  else
    @html_title ||= []
    @html_title += args
  end
end

- (Object) image_to_function(name, function, html_options = {}) 



81
82
83
84
85
86
87
 
# File 'app/helpers/application_helper.rb', line 81

def image_to_function(name, function, html_options = {})
  html_options.symbolize_keys!
  tag(:input, html_options.merge({
      :type => "image", :src => image_path(name),
      :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function};"
      }))
end

- (Object) include_calendar_headers_tags 



604
605
606
607
608
609
610
611
612
613
614
 
# File 'app/helpers/application_helper.rb', line 604

def include_calendar_headers_tags
  unless @calendar_headers_tags_included
    @calendar_headers_tags_included = true
    content_for :header_tags do
      javascript_include_tag('calendar/calendar') +
      javascript_include_tag("calendar/lang/calendar-#{current_language}.js") +
      javascript_include_tag('calendar/calendar-setup') +
      stylesheet_link_tag('calendar')
    end
  end
end

- (Object) label_tag_for(name, option_tags = nil, options = {}) 



544
545
546
547
 
# File 'app/helpers/application_helper.rb', line 544

def label_tag_for(name, option_tags = nil, options = {})
  label_text = l(("field_"+field.to_s.gsub(/\_id$/, "")).to_sym) + (options.delete(:required) ? @template.content_tag("span", " *", :class => "required"): "")
  content_tag("label", label_text)
end

- (Object) labelled_tabular_form_for(name, object, options, &proc) 



549
550
551
552
553
 
# File 'app/helpers/application_helper.rb', line 549

def labelled_tabular_form_for(name, object, options, &proc)
  options[:html] ||= {}
  options[:html][:class] = 'tabular' unless options[:html].has_key?(:class)
  form_for(name, object, options.merge({ :builder => TabularFormBuilder, :lang => current_language}), &proc)
end

- (Object) lang_options_for_select(blank = true) 



539
540
541
542
 
# File 'app/helpers/application_helper.rb', line 539

def lang_options_for_select(blank=true)
  (blank ? [["(auto)", ""]] : []) +
    valid_languages.collect{|lang| [ ll(lang.to_s, :general_lang_name), lang.to_s]}.sort{|x,y| x.last <=> y.last }
end

- (Object) link_to_attachment(attachment, options = {})

Generates a link to an attachment. Options:

  • :text - Link text (default to attachment filename)

  • :download - Force download (default: false)



67
68
69
70
71
72
 
# File 'app/helpers/application_helper.rb', line 67

def link_to_attachment(attachment, options={})
  text = options.delete(:text) || attachment.filename
  action = options.delete(:download) ? 'download' : 'show'

  link_to(h(text), {:controller => 'attachments', :action => action, :id => attachment, :filename => attachment.filename }, options)
end

- (Object) link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)

Display a link if user is authorized



41
42
43
 
# File 'app/helpers/application_helper.rb', line 41

def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)
  link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])
end

- (Object) link_to_issue(issue, options = {}) 



56
57
58
59
60
61
 
# File 'app/helpers/application_helper.rb', line 56

def link_to_issue(issue, options={})
  options[:class] ||= ''
  options[:class] << ' issue'
  options[:class] << ' closed' if issue.closed?
  link_to "#{issue.tracker.name} ##{issue.id}", {:controller => "issues", :action => "show", :id => issue}, options
end

- (Object) link_to_remote_if_authorized(name, options = {}, html_options = nil)

Display a link to remote if user is authorized



46
47
48
49
 
# File 'app/helpers/application_helper.rb', line 46

def link_to_remote_if_authorized(name, options = {}, html_options = nil)
  url = options[:url] || {}
  link_to_remote(name, options, html_options) if authorize_for(url[:controller] || params[:controller], url[:action])
end

- (Object) link_to_user(user, options = {})

Display a link to user's account page



52
53
54
 
# File 'app/helpers/application_helper.rb', line 52

def link_to_user(user, options={})
  (user && !user.anonymous?) ? link_to(user.name(options[:format]), :controller => 'account', :action => 'show', :id => user) : 'Anonymous'
end

- (Object) other_formats_links {|Redmine::Views::OtherFormatsBuilder.new(self)| ... }

Yields:



281
282
283
284
285
 
# File 'app/helpers/application_helper.rb', line 281

def other_formats_links(&block)
  concat('<p class="other-formats">' + l(:label_export_to))
  yield Redmine::Views::OtherFormatsBuilder.new(self)
  concat('</p>')
end

- (Object) page_header_title 



287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
 
# File 'app/helpers/application_helper.rb', line 287

def page_header_title
  if @project.nil? || @project.new_record?
    h(Setting.app_title)
  else
    b = []
    ancestors = (@project.root? ? [] : @project.ancestors.visible)
    if ancestors.any?
      root = ancestors.shift
      b << link_to(h(root), {:controller => 'projects', :action => 'show', :id => root, :jump => current_menu_item}, :class => 'root')
      if ancestors.size > 2
        b << '&#8230;'
        ancestors = ancestors[-2, 2]
      end
      b += ancestors.collect {|p| link_to(h(p), {:controller => 'projects', :action => 'show', :id => p, :jump => current_menu_item}, :class => 'ancestor') }
    end
    b << h(@project)
    b.join(' &#187; ')
  end
end

- (Object) pagination_links_full(paginator, count = nil, options = {}) 



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
 
# File 'app/helpers/application_helper.rb', line 227

def pagination_links_full(paginator, count=nil, options={})
  page_param = options.delete(:page_param) || :page
  url_param = params.dup
  # don't reuse query params if filters are present
  url_param.merge!(:fields => nil, :values => nil, :operators => nil) if url_param.delete(:set_filter)

  html = ''
  if paginator.current.previous
    html << link_to_remote_content_update('&#171; ' + l(:label_previous), url_param.merge(page_param => paginator.current.previous)) + ' '
  end

  html << (pagination_links_each(paginator, options) do |n|
    link_to_remote_content_update(n.to_s, url_param.merge(page_param => n))
  end || '')
  
  if paginator.current.next
    html << ' ' + link_to_remote_content_update((l(:label_next) + ' &#187;'), url_param.merge(page_param => paginator.current.next))
  end

  unless count.nil?
    html << [
      " (#{paginator.current.first_item}-#{paginator.current.last_item}/#{count})",
      per_page_links(paginator.items_per_page)
    ].compact.join(' | ')
  end

  html
end

- (Object) path_to_stylesheet(source) 



73
74
75
 
# File 'lib/redmine/themes.rb', line 73

def path_to_stylesheet(source)
  stylesheet_path source
end

- (Object) per_page_links(selected = nil) 



256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'app/helpers/application_helper.rb', line 256

def per_page_links(selected=nil)
  url_param = params.dup
  url_param.clear if url_param.has_key?(:set_filter)

  links = Setting.per_page_options_array.collect do |n|
    n == selected ? n : link_to_remote(n, {:update => "content",
                                           :url => params.dup.merge(:per_page => n),
                                           :method => :get},
                                          {:href => url_for(url_param.merge(:per_page => n))})
  end
  links.size > 1 ? l(:label_display_per_page, links.join(', ')) : nil
end

- (Object) progress_bar(pcts, options = {}) 



567
568
569
570
571
572
573
574
575
576
577
578
579
580
 
# File 'app/helpers/application_helper.rb', line 567

def progress_bar(pcts, options={})
  pcts = [pcts, pcts] unless pcts.is_a?(Array)
  pcts[1] = pcts[1] - pcts[0]
  pcts << (100 - pcts[1] - pcts[0])
  width = options[:width] || '100px;'
  legend = options[:legend] || ''
  content_tag('table',
    content_tag('tr',
      (pcts[0] > 0 ? content_tag('td', '', :style => "width: #{pcts[0].floor}%;", :class => 'closed') : '') +
      (pcts[1] > 0 ? content_tag('td', '', :style => "width: #{pcts[1].floor}%;", :class => 'done') : '') +
      (pcts[2] > 0 ? content_tag('td', '', :style => "width: #{pcts[2].floor}%;", :class => 'todo') : '')
    ), :class => 'progress', :style => "width: #{width};") +
    content_tag('p', legend, :class => 'pourcent')
end

- (Object) project_nested_ul(projects, &block) 



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'app/helpers/application_helper.rb', line 176

def project_nested_ul(projects, &block)
  s = ''
  if projects.any?
    ancestors = []
    projects.sort_by(&:lft).each do |project|
      if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
        s << "<ul>\n"
      else
        ancestors.pop
        s << "</li>"
        while (ancestors.any? && !project.is_descendant_of?(ancestors.last)) 
          ancestors.pop
          s << "</ul></li>\n"
        end
      end
      s << "<li>"
      s << yield(project).to_s
      ancestors << project
    end
    s << ("</li></ul>\n" * ancestors.size)
  end
  s
end

- (Object) project_tree(projects, &block)

Yields the given block for each project with its level in the tree



165
166
167
168
169
170
171
172
173
174
 
# File 'app/helpers/application_helper.rb', line 165

def project_tree(projects, &block)
  ancestors = []
  projects.sort_by(&:lft).each do |project|
    while (ancestors.any? && !project.is_descendant_of?(ancestors.last)) 
      ancestors.pop
    end
    yield project, ancestors.size
    ancestors << project
  end
end

- (Object) project_tree_options_for_select(projects, options = {}) 



153
154
155
156
157
158
159
160
161
162
 
# File 'app/helpers/application_helper.rb', line 153

def project_tree_options_for_select(projects, options = {})
  s = ''
  project_tree(projects) do |project, level|
    name_prefix = (level > 0 ? ('&nbsp;' * 2 * level + '&#187; ') : '')
    tag_options = {:value => project.id, :selected => ((project == options[:selected]) ? 'selected' : nil)}
    tag_options.merge!(yield(project)) if block_given?
    s << content_tag('option', name_prefix + h(project), tag_options)
  end
  s
end

- (Object) prompt_to_remote(name, text, param, url, html_options = {}) 



89
90
91
92
 
# File 'app/helpers/application_helper.rb', line 89

def prompt_to_remote(name, text, param, url, html_options = {})
  html_options[:onclick] = "promptToRemote('#{text}', '#{param}', '#{url_for(url)}'); return false;"
  link_to name, {}, html_options
end

- (Object) render_flash_messages

Renders flash messages



129
130
131
132
133
134
135
 
# File 'app/helpers/application_helper.rb', line 129

def render_flash_messages
  s = ''
  flash.each do |k,v|
    s << content_tag('div', v, :class => "flash #{k}")
  end
  s
end

- (Object) render_page_hierarchy(pages, node = nil) 



112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'app/helpers/application_helper.rb', line 112

def render_page_hierarchy(pages, node=nil)
  content = ''
  if pages[node]
    content << "<ul class=\"pages-hierarchy\">\n"
    pages[node].each do |page|
      content << "<li>"
      content << link_to(h(page.pretty_title), {:controller => 'wiki', :action => 'index', :id => page.project, :page => page.title},
                         :title => (page.respond_to?(:updated_on) ? l(:label_updated_time, distance_of_time_in_words(Time.now, page.updated_on)) : nil))
      content << "\n" + render_page_hierarchy(pages, page.id) if pages[page.id]
      content << "</li>\n"
    end
    content << "</ul>\n"
  end
  content
end

- (Object) render_project_jump_box

Renders the project quick-jump box



138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'app/helpers/application_helper.rb', line 138

def render_project_jump_box
  # Retrieve them now to avoid a COUNT query
  projects = User.current.projects.all
  if projects.any?
    s = '<select onchange="if (this.value != \'\') { window.location = this.value; }">' +
          "<option selected='selected'>#{ l(:label_jump_to_a_project) }</option>" +
          '<option disabled="disabled">---</option>'
    s << project_tree_options_for_select(projects) do |p|
      { :value => url_for(:controller => 'projects', :action => 'show', :id => p, :jump => current_menu_item) }
    end
    s << '</select>'
    s
  end
end

- (Object) reorder_links(name, url) 



269
270
271
272
273
274
 
# File 'app/helpers/application_helper.rb', line 269

def reorder_links(name, url)
  link_to(image_tag('2uparrow.png',   :alt => l(:label_sort_highest)), url.merge({"#{name}[move_to]" => 'highest'}), :method => :post, :title => l(:label_sort_highest)) +
  link_to(image_tag('1uparrow.png',   :alt => l(:label_sort_higher)),  url.merge({"#{name}[move_to]" => 'higher'}),  :method => :post, :title => l(:label_sort_higher)) +
  link_to(image_tag('1downarrow.png', :alt => l(:label_sort_lower)),   url.merge({"#{name}[move_to]" => 'lower'}),   :method => :post, :title => l(:label_sort_lower)) +
  link_to(image_tag('2downarrow.png', :alt => l(:label_sort_lowest)),  url.merge({"#{name}[move_to]" => 'lowest'}),  :method => :post, :title => l(:label_sort_lowest))
end

- (Object) simple_format_without_paragraph(text)

Same as Rails' simple_format helper without using paragraphs



532
533
534
535
536
537
 
# File 'app/helpers/application_helper.rb', line 532

def simple_format_without_paragraph(text)
  text.to_s.
    gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
    gsub(/\n\n+/, "<br /><br />").          # 2+ newline  -> 2 br
    gsub(/([^\n]\n)(?=[^\n])/, '\1<br />')  # 1 newline   -> br
end

- (Object) stylesheet_path(source) 



67
68
69
70
71
 
# File 'lib/redmine/themes.rb', line 67

def stylesheet_path(source)
  @current_theme ||= Redmine::Themes.theme(Setting.ui_theme)
  super((@current_theme && @current_theme.stylesheets.include?(source)) ?
    "/themes/#{@current_theme.dir}/stylesheets/#{source}" : source)
end

- (Object) syntax_highlight(name, content) 



218
219
220
221
 
# File 'app/helpers/application_helper.rb', line 218

def syntax_highlight(name, content)
  type = CodeRay::FileType[name]
  type ? CodeRay.scan(content, type).html : h(content)
end

- (Object) textilizable(*args)

Formats text according to system settings. 2 ways to call this method:

  • with a String: textilizable(text, options)

  • with an object and one of its attribute: textilizable(issue, :description, options)



328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
 
# File 'app/helpers/application_helper.rb', line 328

def textilizable(*args)
  options = args.last.is_a?(Hash) ? args.pop : {}
  case args.size
  when 1
    obj = options[:object]
    text = args.shift
  when 2
    obj = args.shift
    text = obj.send(args.shift).to_s
  else
    raise ArgumentError, 'invalid arguments to textilizable'
  end
  return '' if text.blank?

  only_path = options.delete(:only_path) == false ? false : true

  # when using an image link, try to use an attachment, if possible
  attachments = options[:attachments] || (obj && obj.respond_to?(:attachments) ? obj.attachments : nil)

  if attachments
    attachments = attachments.sort_by(&:created_on).reverse
    text = text.gsub(/!((\<|\=|\>)?(\([^\)]+\))?(\[[^\]]+\])?(\{[^\}]+\})?)(\S+\.(bmp|gif|jpg|jpeg|png))!/i) do |m|
      style = $1
      filename = $6.downcase
      # search for the picture in attachments
      if found = attachments.detect { |att| att.filename.downcase == filename }
        image_url = url_for :only_path => only_path, :controller => 'attachments', :action => 'download', :id => found
        desc = found.description.to_s.gsub(/^([^\(\)]*).*$/, "\\1")
        alt = desc.blank? ? nil : "(#{desc})"
        "!#{style}#{image_url}#{alt}!"
      else
        m
      end
    end
  end

  text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text) { |macro, args| exec_macro(macro, obj, args) }

  # different methods for formatting wiki links
  case options[:wiki_links]
  when :local
    # used for local links to html files
    format_wiki_link = Proc.new {|project, title, anchor| "#{title}.html" }
  when :anchor
    # used for single-file wiki export
    format_wiki_link = Proc.new {|project, title, anchor| "##{title}" }
  else
    format_wiki_link = Proc.new {|project, title, anchor| url_for(:only_path => only_path, :controller => 'wiki', :action => 'index', :id => project, :page => title, :anchor => anchor) }
  end

  project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)

  # Wiki links
  #
  # Examples:
  #   [[mypage]]
  #   [[mypage|mytext]]
  # wiki links can refer other project wikis, using project name or identifier:
  #   [[project:]] -> wiki starting page
  #   [[project:|mytext]]
  #   [[project:mypage]]
  #   [[project:mypage|mytext]]
  text = text.gsub(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
    link_project = project
    esc, all, page, title = $1, $2, $3, $5
    if esc.nil?
      if page =~ /^([^\:]+)\:(.*)$/
        link_project = Project.find_by_name($1) || Project.find_by_identifier($1)
        page = $2
        title ||= $1 if page.blank?
      end

      if link_project && link_project.wiki
        # extract anchor
        anchor = nil
        if page =~ /^(.+?)\#(.+)$/
          page, anchor = $1, $2
        end
        # check if page exists
        wiki_page = link_project.wiki.find_page(page)
        link_to((title || page), format_wiki_link.call(link_project, Wiki.titleize(page), anchor),
                                 :class => ('wiki-page' + (wiki_page ? '' : ' new')))
      else
        # project or wiki doesn't exist
        all
      end
    else
      all
    end
  end

  # Redmine links
  #
  # Examples:
  #   Issues:
  #     #52 -> Link to issue #52
  #   Changesets:
  #     r52 -> Link to revision 52
  #     commit:a85130f -> Link to scmid starting with a85130f
  #   Documents:
  #     document#17 -> Link to document with id 17
  #     document:Greetings -> Link to the document with title "Greetings"
  #     document:"Some document" -> Link to the document with title "Some document"
  #   Versions:
  #     version#3 -> Link to version with id 3
  #     version:1.0.0 -> Link to version named "1.0.0"
  #     version:"1.0 beta 2" -> Link to version named "1.0 beta 2"
  #   Attachments:
  #     attachment:file.zip -> Link to the attachment of the current object named file.zip
  #   Source files:
  #     source:some/file -> Link to the file located at /some/file in the project's repository
  #     source:some/file@52 -> Link to the file's revision 52
  #     source:some/file#L120 -> Link to line 120 of the file
  #     source:some/file@52#L120 -> Link to line 120 of the file's revision 52
  #     export:some/file -> Force the download of the file
  #  Forum messages:
  #     message#1218 -> Link to message with id 1218
  text = text.gsub(%r{([\s\(,\-\>]|^)(!)?(attachment|document|version|commit|source|export|message)?((#|r)(\d+)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]]\W)|\s|<|$)}) do |m|
    leading, esc, prefix, sep, oid = $1, $2, $3, $5 || $7, $6 || $8
    link = nil
    if esc.nil?
      if prefix.nil? && sep == 'r'
        if project && (changeset = project.changesets.find_by_revision(oid))
          link = link_to("r#{oid}", {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => oid},
                                    :class => 'changeset',
                                    :title => truncate_single_line(changeset.comments, :length => 100))
        end
      elsif sep == '#'
        oid = oid.to_i
        case prefix
        when nil
          if issue = Issue.find_by_id(oid, :include => [:project, :status], :conditions => Project.visible_by(User.current))
            link = link_to("##{oid}", {:only_path => only_path, :controller => 'issues', :action => 'show', :id => oid},
                                      :class => (issue.closed? ? 'issue closed' : 'issue'),
                                      :title => "#{truncate(issue.subject, :length => 100)} (#{issue.status.name})")
            link = content_tag('del', link) if issue.closed?
          end
        when 'document'
          if document = Document.find_by_id(oid, :include => [:project], :conditions => Project.visible_by(User.current))
            link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                              :class => 'document'
          end
        when 'version'
          if version = Version.find_by_id(oid, :include => [:project], :conditions => Project.visible_by(User.current))
            link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                            :class => 'version'
          end
        when 'message'
          if message = Message.find_by_id(oid, :include => [:parent, {:board => :project}], :conditions => Project.visible_by(User.current))
            link = link_to h(truncate(message.subject, :length => 60)), {:only_path => only_path,
                                                              :controller => 'messages',
                                                              :action => 'show',
                                                              :board_id => message.board,
                                                              :id => message.root,
                                                              :anchor => (message.parent ? "message-#{message.id}" : nil)},
                                               :class => 'message'
          end
        end
      elsif sep == ':'
        # removes the double quotes if any
        name = oid.gsub(%r{^"(.*)"$}, "\\1")
        case prefix
        when 'document'
          if project && document = project.documents.find_by_title(name)
            link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                              :class => 'document'
          end
        when 'version'
          if project && version = project.versions.find_by_name(name)
            link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                            :class => 'version'
          end
        when 'commit'
          if project && (changeset = project.changesets.find(:first, :conditions => ["scmid LIKE ?", "#{name}%"]))
            link = link_to h("#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => changeset.revision},
                                         :class => 'changeset',
                                         :title => truncate_single_line(changeset.comments, :length => 100)
          end
        when 'source', 'export'
          if project && project.repository
            name =~ %r{^[/\\]*(.*?)(@([0-9a-f]+))?(#(L\d+))?$}
            path, rev, anchor = $1, $3, $5
            link = link_to h("#{prefix}:#{name}"), {:controller => 'repositories', :action => 'entry', :id => project,
                                                    :path => to_path_param(path),
                                                    :rev => rev,
                                                    :anchor => anchor,
                                                    :format => (prefix == 'export' ? 'raw' : nil)},
                                                   :class => (prefix == 'export' ? 'source download' : 'source')
          end
        when 'attachment'
          if attachments && attachment = attachments.detect {|a| a.filename == name }
            link = link_to h(attachment.filename), {:only_path => only_path, :controller => 'attachments', :action => 'download', :id => attachment},
                                                   :class => 'attachment'
          end
        end
      end
    end
    leading + (link || "#{prefix}#{sep}#{oid}")
  end

  text
end

- (Object) to_path_param(path) 



223
224
225
 
# File 'app/helpers/application_helper.rb', line 223

def to_path_param(path)
  path.to_s.split(%r{[/\\]}).select {|p| !p.blank?}
end

- (Object) toggle_link(name, id, options = {}) 



74
75
76
77
78
79
 
# File 'app/helpers/application_helper.rb', line 74

def toggle_link(name, id, options={})
  onclick = "Element.toggle('#{id}'); "
  onclick << (options[:focus] ? "Form.Element.focus('#{options[:focus]}'); " : "this.blur(); ")
  onclick << "return false;"
  link_to(name, "#", :onclick => onclick)
end

- (Object) truncate_single_line(string, *args)

Truncates and returns the string as a single line



201
202
203
 
# File 'app/helpers/application_helper.rb', line 201

def truncate_single_line(string, *args)
  truncate(string, *args).gsub(%r{[\r\n]+}m, ' ')
end