jro_apps/redmine Commit - r10324:2df7c0ff3a60

Merged r10465 from trunk....

Jean-Philippe Lang -

r10324:2df7c0ff3a60

parent child

Context file:

r10324:2df7c0ff3a60

Collapse all files

app/helpers/application_helper.rb +5 0

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'forwardable'
             require 'cgi'
             module ApplicationHelper
               include Redmine::WikiFormatting::Macros::Definitions
               include Redmine::I18n
               include GravatarHelper::PublicMethods
               extend Forwardable
               def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
               # Return true if user is authorized for controller/action, otherwise false
               def authorize_for(controller, action)
                 User.current.allowed_to?({:controller => controller, :action => action}, @project)
               end
               # Display a link if user is authorized
               #
               # @param [String] name Anchor text (passed to link_to)
               # @param [Hash] options Hash params. This will checked by authorize_for to see if the user is authorized
               # @param [optional, Hash] html_options Options passed to link_to
               # @param [optional, Hash] parameters_for_method_reference Extra parameters for link_to
               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
               # Displays a link to user's account page if active
               def link_to_user(user, options={})
                 if user.is_a?(User)
                   name = h(user.name(options[:format]))
                   if user.active?
                     link_to name, :controller => 'users', :action => 'show', :id => user
                   else
                     name
                   end
                 else
                   h(user.to_s)
                 end
               end
               # Displays a link to +issue+ with its subject.
               # Examples:
               #
               #   link_to_issue(issue)                        # => Defect #6: This is the subject
               #   link_to_issue(issue, :truncate => 6)        # => Defect #6: This i...
               #   link_to_issue(issue, :subject => false)     # => Defect #6
               #   link_to_issue(issue, :project => true)      # => Foo - Defect #6
               #
               def link_to_issue(issue, options={})
                 title = nil
                 subject = nil
                 if options[:subject] == false
                   title = truncate(issue.subject, :length => 60)
                 else
                   subject = issue.subject
                   if options[:truncate]
                     subject = truncate(subject, :length => options[:truncate])
                   end
                 end
                 s = link_to "#{h(issue.tracker)} ##{issue.id}", {:controller => "issues", :action => "show", :id => issue},
                                                              :class => issue.css_classes,
                                                              :title => title
                 s << h(": #{subject}") if subject
                 s = h("#{issue.project} - ") + s if options[:project]
                 s
               end
               # Generates a link to an attachment.
               # Options:
               # * :text - Link text (default to attachment filename)
               # * :download - Force download (default: false)
               def link_to_attachment(attachment, options={})
                 text = options.delete(:text) || attachment.filename
                 action = options.delete(:download) ? 'download' : 'show'
                 opt_only_path = {}
                 opt_only_path[:only_path] = (options[:only_path] == false ? false : true)
                 options.delete(:only_path)
                 link_to(h(text),
                        {:controller => 'attachments', :action => action,
                         :id => attachment, :filename => attachment.filename}.merge(opt_only_path),
                        options)
               end
               # Generates a link to a SCM revision
               # Options:
               # * :text - Link text (default to the formatted revision)
               def link_to_revision(revision, repository, options={})
                 if repository.is_a?(Project)
                   repository = repository.repository
                 end
                 text = options.delete(:text) || format_revision(revision)
                 rev = revision.respond_to?(:identifier) ? revision.identifier : revision
                 link_to(
                     h(text),
                     {:controller => 'repositories', :action => 'revision', :id => repository.project, :repository_id => repository.identifier_param, :rev => rev},
                     :title => l(:label_revision_id, format_revision(revision))
                   )
               end
               # Generates a link to a message
               def link_to_message(message, options={}, html_options = nil)
                 link_to(
                   h(truncate(message.subject, :length => 60)),
                   { :controller => 'messages', :action => 'show',
                     :board_id => message.board_id,
                     :id => (message.parent_id || message.id),
                     :r => (message.parent_id && message.id),
                     :anchor => (message.parent_id ? "message-#{message.id}" : nil)
                   }.merge(options),
                   html_options
                 )
               end
               # Generates a link to a project if active
               # Examples:
               #
               #   link_to_project(project)                          # => link to the specified project overview
               #   link_to_project(project, :action=>'settings')     # => link to project settings
               #   link_to_project(project, {:only_path => false}, :class => "project") # => 3rd arg adds html options
               #   link_to_project(project, {}, :class => "project") # => html options with default url (project overview)
               #
               def link_to_project(project, options={}, html_options = nil)
                 if project.archived?
                   h(project)
                 else
                   url = {:controller => 'projects', :action => 'show', :id => project}.merge(options)
                   link_to(h(project), url, html_options)
                 end
               end
               def thumbnail_tag(attachment)
                 link_to image_tag(url_for(:controller => 'attachments', :action => 'thumbnail', :id => attachment)),
                   {:controller => 'attachments', :action => 'show', :id => attachment, :filename => attachment.filename},
                   :title => attachment.filename
               end
               def toggle_link(name, id, options={})
                 onclick = "$('##{id}').toggle(); "
                 onclick << (options[:focus] ? "$('##{options[:focus]}').focus(); " : "this.blur(); ")
                 onclick << "return false;"
                 link_to(name, "#", :onclick => onclick)
               end
               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
               def format_activity_title(text)
                 h(truncate_single_line(text, :length => 100))
               end
               def format_activity_day(date)
                 date == User.current.today ? l(:label_today).titleize : format_date(date)
               end
               def format_activity_description(text)
                 h(truncate(text.to_s, :length => 120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')
                    ).gsub(/[\r\n]+/, "<br />").html_safe
               end
               def format_version_name(version)
                 if version.project == @project
                 	h(version)
                 else
                   h("#{version.project} - #{version}")
                 end
               end
               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
               # Renders a tree of projects as a nested set of unordered lists
               # The given collection may be a subset of the whole project tree
               # (eg. some intermediate nodes are private and can not be seen)
               def render_project_nested_lists(projects)
                 s = ''
                 if projects.any?
                   ancestors = []
                   original_project = @project
                   projects.sort_by(&:lft).each do |project|
                     # set the project environment to please macros.
                     @project = project
                     if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
                       s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>\n"
                     else
                       ancestors.pop
                       s << "</li>"
                       while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                         ancestors.pop
                         s << "</ul></li>\n"
                       end
                     end
                     classes = (ancestors.empty? ? 'root' : 'child')
                     s << "<li class='#{classes}'><div class='#{classes}'>"
                     s << h(block_given? ? yield(project) : project.name)
                     s << "</div>\n"
                     ancestors << project
                   end
                   s << ("</li></ul>\n" * ancestors.size)
                   @project = original_project
                 end
                 s.html_safe
               end
               def render_page_hierarchy(pages, node=nil, options={})
                 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 => 'show', :project_id => page.project, :id => page.title},
                                        :title => (options[:timestamp] && page.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, options) if pages[page.id]
                     content << "</li>\n"
                   end
                   content << "</ul>\n"
                 end
                 content.html_safe
               end
               # Renders flash messages
               def render_flash_messages
                 s = ''
                 flash.each do |k,v|
                   s << content_tag('div', v.html_safe, :class => "flash #{k}", :id => "flash_#{k}")
                 end
                 s.html_safe
               end
               # Renders tabs and their content
               def render_tabs(tabs)
                 if tabs.any?
                   render :partial => 'common/tabs', :locals => {:tabs => tabs}
                 else
                   content_tag 'p', l(:label_no_data), :class => "nodata"
                 end
               end
               # Renders the project quick-jump box
               def render_project_jump_box
                 return unless User.current.logged?
                 projects = User.current.memberships.collect(&:project).compact.select(&:active?).uniq
                 if projects.any?
                   options =
                     ("<option value=''>#{ l(:label_jump_to_a_project) }</option>" +
                      '<option value="" disabled="disabled">---</option>').html_safe
                   options << project_tree_options_for_select(projects, :selected => @project) do |p|
                     { :value => project_path(:id => p, :jump => current_menu_item) }
                   end
                   select_tag('project_quick_jump_box', options, :onchange => 'if (this.value != \'\') { window.location = this.value; }')
                 end
               end
               def project_tree_options_for_select(projects, options = {})
                 s = ''
                 project_tree(projects) do |project, level|
                   name_prefix = (level > 0 ? '&nbsp;' * 2 * level + '&#187; ' : '').html_safe
                   tag_options = {:value => project.id}
                   if project == options[:selected] || (options[:selected].respond_to?(:include?) && options[:selected].include?(project))
                     tag_options[:selected] = 'selected'
                   else
                     tag_options[:selected] = nil
                   end
                   tag_options.merge!(yield(project)) if block_given?
                   s << content_tag('option', name_prefix + h(project), tag_options)
                 end
                 s.html_safe
               end
               # Yields the given block for each project with its level in the tree
               #
               # Wrapper for Project#project_tree
               def project_tree(projects, &block)
                 Project.project_tree(projects, &block)
               end
               def principals_check_box_tags(name, principals)
                 s = ''
                 principals.sort.each do |principal|
                   s << "<label>#{ check_box_tag name, principal.id, false } #{h principal}</label>\n"
                 end
                 s.html_safe
               end
               # Returns a string for users/groups option tags
               def principals_options_for_select(collection, selected=nil)
                 s = ''
                 if collection.include?(User.current)
                   s << content_tag('option', "<< #{l(:label_me)} >>", :value => User.current.id)
                 end
                 groups = ''
                 collection.sort.each do |element|
                   selected_attribute = ' selected="selected"' if option_value_selected?(element, selected)
                   (element.is_a?(Group) ? groups : s) << %(<option value="#{element.id}"#{selected_attribute}>#{h element.name}</option>)
                 end
                 unless groups.empty?
                   s << %(<optgroup label="#{h(l(:label_group_plural))}">#{groups}</optgroup>)
                 end
                 s.html_safe
               end
               # Truncates and returns the string as a single line
               def truncate_single_line(string, *args)
                 truncate(string.to_s, *args).gsub(%r{[\r\n]+}m, ' ')
               end
               # Truncates at line break after 250 characters or options[:length]
               def truncate_lines(string, options={})
                 length = options[:length] || 250
                 if string.to_s =~ /\A(.{#{length}}.*?)$/m
                   "#{$1}..."
                 else
                   string
                 end
               end
               def anchor(text)
                 text.to_s.gsub(' ', '_')
               end
               def html_hours(text)
                 text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>').html_safe
               end
               def authoring(created, author, options={})
                 l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created)).html_safe
               end
               def time_tag(time)
                 text = distance_of_time_in_words(Time.now, time)
                 if @project
                   link_to(text, {:controller => 'activities', :action => 'index', :id => @project, :from => User.current.time_to_date(time)}, :title => format_time(time))
                 else
                   content_tag('acronym', text, :title => format_time(time))
                 end
               end
               def syntax_highlight_lines(name, content)
                 lines = []
                 syntax_highlight(name, content).each_line { |line| lines << line }
                 lines
               end
               def syntax_highlight(name, content)
                 Redmine::SyntaxHighlighting.highlight_by_filename(content, name)
               end
               def to_path_param(path)
                 str = path.to_s.split(%r{[/\\]}).select{|p| !p.blank?}.join("/")
                 str.blank? ? nil : str
               end
               def pagination_links_full(paginator, count=nil, options={})
                 page_param = options.delete(:page_param) || :page
                 per_page_links = options.delete(:per_page_links)
                 url_param = params.dup
                 html = ''
                 if paginator.current.previous
                   # \xc2\xab(utf-8) = &#171;
                   html << link_to_content_update(
                                "\xc2\xab " + l(:label_previous),
                                url_param.merge(page_param => paginator.current.previous)) + ' '
                 end
                 html << (pagination_links_each(paginator, options) do |n|
                   link_to_content_update(n.to_s, url_param.merge(page_param => n))
                 end || '')
                 if paginator.current.next
                   # \xc2\xbb(utf-8) = &#187;
                   html << ' ' + link_to_content_update(
                                   (l(:label_next) + " \xc2\xbb"),
                                   url_param.merge(page_param => paginator.current.next))
                 end
                 unless count.nil?
                   html << " (#{paginator.current.first_item}-#{paginator.current.last_item}/#{count})"
                   if per_page_links != false && links = per_page_links(paginator.items_per_page, count)
             	      html << " | #{links}"
                   end
                 end
                 html.html_safe
               end
               def per_page_links(selected=nil, item_count=nil)
                 values = Setting.per_page_options_array
                 if item_count && values.any?
                   if item_count > values.first
                     max = values.detect {|value| value >= item_count} || item_count
                   else
                     max = item_count
                   end
                   values = values.select {|value| value <= max || value == selected}
                 end
                 if values.empty? || (values.size == 1 && values.first == selected)
                   return nil
                 end
                 links = values.collect do |n|
                   n == selected ? n : link_to_content_update(n, params.merge(:per_page => n))
                 end
                 l(:label_display_per_page, links.join(', '))
               end
               def reorder_links(name, url, method = :post)
                 link_to(image_tag('2uparrow.png', :alt => l(:label_sort_highest)),
                         url.merge({"#{name}[move_to]" => 'highest'}),
                         :method => method, :title => l(:label_sort_highest)) +
                 link_to(image_tag('1uparrow.png',   :alt => l(:label_sort_higher)),
                         url.merge({"#{name}[move_to]" => 'higher'}),
                        :method => method, :title => l(:label_sort_higher)) +
                 link_to(image_tag('1downarrow.png', :alt => l(:label_sort_lower)),
                         url.merge({"#{name}[move_to]" => 'lower'}),
                         :method => method, :title => l(:label_sort_lower)) +
                 link_to(image_tag('2downarrow.png', :alt => l(:label_sort_lowest)),
                         url.merge({"#{name}[move_to]" => 'lowest'}),
                        :method => method, :title => l(:label_sort_lowest))
               end
               def breadcrumb(*args)
                 elements = args.flatten
                 elements.any? ? content_tag('p', (args.join(" \xc2\xbb ") + " \xc2\xbb ").html_safe, :class => 'breadcrumb') : nil
               end
               def other_formats_links(&block)
                 concat('<p class="other-formats">'.html_safe + l(:label_export_to))
                 yield Redmine::Views::OtherFormatsBuilder.new(self)
                 concat('</p>'.html_safe)
               end
               def page_header_title
                 if @project.nil? || @project.new_record?
                   h(Setting.app_title)
                 else
                   b = []
                   ancestors = (@project.root? ? [] : @project.ancestors.visible.all)
                   if ancestors.any?
                     root = ancestors.shift
                     b << link_to_project(root, {:jump => current_menu_item}, :class => 'root')
                     if ancestors.size > 2
                       b << "\xe2\x80\xa6"
                       ancestors = ancestors[-2, 2]
                     end
                     b += ancestors.collect {|p| link_to_project(p, {:jump => current_menu_item}, :class => 'ancestor') }
                   end
                   b << h(@project)
                   b.join(" \xc2\xbb ").html_safe
                 end
               end
               def html_title(*args)
                 if args.empty?
                   title = @html_title || []
                   title << @project.name if @project
                   title << Setting.app_title unless Setting.app_title == title.last
                   title.select {|t| !t.blank? }.join(' - ')
                 else
                   @html_title ||= []
                   @html_title += args
                 end
               end
               # Returns the theme, controller name, and action as css classes for the
               # HTML body.
               def body_css_classes
                 css = []
                 if theme = Redmine::Themes.theme(Setting.ui_theme)
                   css << 'theme-' + theme.name
                 end
                 css << 'controller-' + controller_name
                 css << 'action-' + action_name
                 css.join(' ')
               end
               def accesskey(s)
                 Redmine::AccessKeys.key_for s
               end
               # 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)
               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
                   attr = args.shift
                   text = obj.send(attr).to_s
                 else
                   raise ArgumentError, 'invalid arguments to textilizable'
                 end
                 return '' if text.blank?
                 project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                 only_path = options.delete(:only_path) == false ? false : true
                 text = text.dup
                 macros = catch_macros(text)
                 text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text, :object => obj, :attribute => attr)
                 @parsed_headings = []
                 @heading_anchors = {}
                 @current_section = 0 if options[:edit_section_links]
                 parse_sections(text, project, obj, attr, only_path, options)
                 text = parse_non_pre_blocks(text, obj, macros) do |text|
                   [:parse_inline_attachments, :parse_wiki_links, :parse_redmine_links].each do |method_name|
                     send method_name, text, project, obj, attr, only_path, options
                   end
                 end
                 parse_headings(text, project, obj, attr, only_path, options)
                 if @parsed_headings.any?
                   replace_toc(text, @parsed_headings)
                 end
                 text.html_safe
               end
               def parse_non_pre_blocks(text, obj, macros)
                 s = StringScanner.new(text)
                 tags = []
                 parsed = ''
                 while !s.eos?
                   s.scan(/(.*?)(<(\/)?(pre|code)(.*?)>|\z)/im)
                   text, full_tag, closing, tag = s[1], s[2], s[3], s[4]
                   if tags.empty?
                     yield text
                     inject_macros(text, obj, macros) if macros.any?
                   else
                     inject_macros(text, obj, macros, false) if macros.any?
                   end
                   parsed << text
                   if tag
                     if closing
                       if tags.last == tag.downcase
                         tags.pop
                       end
                     else
                       tags << tag.downcase
                     end
                     parsed << full_tag
                   end
                 end
                 # Close any non closing tags
                 while tag = tags.pop
                   parsed << "</#{tag}>"
                 end
                 parsed
               end
               def parse_inline_attachments(text, project, obj, attr, only_path, options)
                 # when using an image link, try to use an attachment, if possible
                 if options[:attachments] || (obj && obj.respond_to?(:attachments))
                   attachments = options[:attachments] || obj.attachments
                   text.gsub!(/src="([^\/"]+\.(bmp|gif|jpg|jpe|jpeg|png))"(\s+alt="([^"]*)")?/i) do |m|
                     filename, ext, alt, alttext = $1.downcase, $2, $3, $4
                     # search for the picture in attachments
                     if found = Attachment.latest_attach(attachments, filename)
                       image_url = url_for :only_path => only_path, :controller => 'attachments',
                                           :action => 'download', :id => found
                       desc = found.description.to_s.gsub('"', '')
                       if !desc.blank? && alttext.blank?
                         alt = " title=\"#{desc}\" alt=\"#{desc}\""
                       end
                       "src=\"#{image_url}\"#{alt}"
                     else
                       m
                     end
                   end
                 end
               end
               # 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]]
               def parse_wiki_links(text, project, obj, attr, only_path, options)
                 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_identifier($1) || Project.find_by_name($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
                       anchor = sanitize_anchor_name(anchor) if anchor.present?
                       # check if page exists
                       wiki_page = link_project.wiki.find_page(page)
                       url = if anchor.present? && wiki_page.present? && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version)) && obj.page == wiki_page
                         "##{anchor}"
                       else
                         case options[:wiki_links]
                         when :local; "#{page.present? ? Wiki.titleize(page) : ''}.html" + (anchor.present? ? "##{anchor}" : '')
                         when :anchor; "##{page.present? ? Wiki.titleize(page) : title}" + (anchor.present? ? "_#{anchor}" : '') # used for single-file wiki export
                         else
                           wiki_page_id = page.present? ? Wiki.titleize(page) : nil
                           parent = wiki_page.nil? && obj.is_a?(WikiContent) && obj.page && project == link_project ? obj.page.title : nil
                           url_for(:only_path => only_path, :controller => 'wiki', :action => 'show', :project_id => link_project,
                            :id => wiki_page_id, :anchor => anchor, :parent => parent)
                         end
                       end
                       link_to(title.present? ? title.html_safe : h(page), url, :class => ('wiki-page' + (wiki_page ? '' : ' new')))
                     else
                       # project or wiki doesn't exist
                       all
                     end
                   else
                     all
                   end
                 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
               #
               #   Links can refer other objects from other projects, using project identifier:
               #     identifier:r52
               #     identifier:document:"Some document"
               #     identifier:version:1.0.0
               #     identifier:source:some/file
               def parse_redmine_links(text, project, obj, attr, only_path, options)
                 text.gsub!(%r{([\s\(,\-\[\>]|^)(!)?(([a-z0-9\-_]+):)?(attachment|document|version|forum|news|message|project|commit|source|export)?(((#)|((([a-z0-9\-]+)\|)?(r)))((\d+)((#note)?-(\d+))?)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]][^A-Za-z0-9_/])|,|\s|\]|<|$)}) do |m|
                   leading, esc, project_prefix, project_identifier, prefix, repo_prefix, repo_identifier, sep, identifier, comment_suffix, comment_id = $1, $2, $3, $4, $5, $10, $11, $8 || $12 || $18, $14 || $19, $15, $17
                   link = nil
                   if project_identifier
                     project = Project.visible.find_by_identifier(project_identifier)
                   end
                   if esc.nil?
                     if prefix.nil? && sep == 'r'
                       if project
                         repository = nil
                         if repo_identifier
                           repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                         else
                           repository = project.repository
                         end
                         # project.changesets.visible raises an SQL error because of a double join on repositories
                         if repository && (changeset = Changeset.visible.find_by_repository_id_and_revision(repository.id, identifier))
                           link = link_to(h("#{project_prefix}#{repo_prefix}r#{identifier}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.revision},
                                                     :class => 'changeset',
                                                     :title => truncate_single_line(changeset.comments, :length => 100))
                         end
                       end
                     elsif sep == '#'
                       oid = identifier.to_i
                       case prefix
                       when nil
                         if oid.to_s == identifier && issue = Issue.visible.find_by_id(oid, :include => :status)
                           anchor = comment_id ? "note-#{comment_id}" : nil
                           link = link_to("##{oid}", {:only_path => only_path, :controller => 'issues', :action => 'show', :id => oid, :anchor => anchor},
                                                     :class => issue.css_classes,
                                                     :title => "#{truncate(issue.subject, :length => 100)} (#{issue.status.name})")
                         end
                       when 'document'
                         if document = Document.visible.find_by_id(oid)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if version = Version.visible.find_by_id(oid)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'message'
                         if message = Message.visible.find_by_id(oid, :include => :parent)
                           link = link_to_message(message, {:only_path => only_path}, :class => 'message')
                         end
                       when 'forum'
                         if board = Board.visible.find_by_id(oid)
                           link = link_to h(board.name), {:only_path => only_path, :controller => 'boards', :action => 'show', :id => board, :project_id => board.project},
                                                          :class => 'board'
                         end
                       when 'news'
                         if news = News.visible.find_by_id(oid)
                           link = link_to h(news.title), {:only_path => only_path, :controller => 'news', :action => 'show', :id => news},
                                                         :class => 'news'
                         end
                       when 'project'
                         if p = Project.visible.find_by_id(oid)
                           link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                         end
                       end
                     elsif sep == ':'
                       # removes the double quotes if any
                       name = identifier.gsub(%r{^"(.*)"$}, "\\1")
                       case prefix
                       when 'document'
                         if project && document = project.documents.visible.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.visible.find_by_name(name)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'forum'
                         if project && board = project.boards.visible.find_by_name(name)
                           link = link_to h(board.name), {:only_path => only_path, :controller => 'boards', :action => 'show', :id => board, :project_id => board.project},
                                                          :class => 'board'
                         end
                       when 'news'
                         if project && news = project.news.visible.find_by_title(name)
                           link = link_to h(news.title), {:only_path => only_path, :controller => 'news', :action => 'show', :id => news},
                                                         :class => 'news'
                         end
                       when 'commit', 'source', 'export'
                         if project
                           repository = nil
                           if name =~ %r{^(([a-z0-9\-]+)\|)(.+)$}
                             repo_prefix, repo_identifier, name = $1, $2, $3
                             repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                           else
                             repository = project.repository
                           end
                           if prefix == 'commit'
                             if repository && (changeset = Changeset.visible.find(:first, :conditions => ["repository_id = ? AND scmid LIKE ?", repository.id, "#{name}%"]))
                               link = link_to h("#{project_prefix}#{repo_prefix}#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.identifier},
                                                            :class => 'changeset',
                                                            :title => truncate_single_line(h(changeset.comments), :length => 100)
                             end
                           else
                             if repository && User.current.allowed_to?(:browse_repository, project)
                               name =~ %r{^[/\\]*(.*?)(@([0-9a-f]+))?(#(L\d+))?$}
                               path, rev, anchor = $1, $3, $5
                               link = link_to h("#{project_prefix}#{prefix}:#{repo_prefix}#{name}"), {:controller => 'repositories', :action => 'entry', :id => project, :repository_id => repository.identifier_param,
                                                                       :path => to_path_param(path),
                                                                       :rev => rev,
                                                                       :anchor => anchor,
                                                                       :format => (prefix == 'export' ? 'raw' : nil)},
                                                                      :class => (prefix == 'export' ? 'source download' : 'source')
                             end
                           end
                           repo_prefix = nil
                         end
                       when 'attachment'
                         attachments = options[:attachments] || (obj && obj.respond_to?(:attachments) ? obj.attachments : nil)
                         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
                       when 'project'
                         if p = Project.visible.find(:first, :conditions => ["identifier = :s OR LOWER(name) = :s", {:s => name.downcase}])
                           link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                         end
                       end
                     end
                   end
                   (leading + (link || "#{project_prefix}#{prefix}#{repo_prefix}#{sep}#{identifier}#{comment_suffix}"))
                 end
               end
               HEADING_RE = /(<h(\d)( [^>]+)?>(.+?)<\/h(\d)>)/i unless const_defined?(:HEADING_RE)
               def parse_sections(text, project, obj, attr, only_path, options)
                 return unless options[:edit_section_links]
                 text.gsub!(HEADING_RE) do
                   heading = $1
                   @current_section += 1
                   if @current_section > 1
                     content_tag('div',
                       link_to(image_tag('edit.png'), options[:edit_section_links].merge(:section => @current_section)),
                       :class => 'contextual',
                       :title => l(:button_edit_section)) + heading.html_safe
                   else
                     heading
                   end
                 end
               end
               # Headings and TOC
               # Adds ids and links to headings unless options[:headings] is set to false
               def parse_headings(text, project, obj, attr, only_path, options)
                 return if options[:headings] == false
                 text.gsub!(HEADING_RE) do
                   level, attrs, content = $2.to_i, $3, $4
                   item = strip_tags(content).strip
                   anchor = sanitize_anchor_name(item)
                   # used for single-file wiki export
                   anchor = "#{obj.page.title}_#{anchor}" if options[:wiki_links] == :anchor && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version))
                   @heading_anchors[anchor] ||= 0
                   idx = (@heading_anchors[anchor] += 1)
                   if idx > 1
                     anchor = "#{anchor}-#{idx}"
                   end
                   @parsed_headings << [level, anchor, item]
                   "<a name=\"#{anchor}\"></a>\n<h#{level} #{attrs}>#{content}<a href=\"##{anchor}\" class=\"wiki-anchor\">&para;</a></h#{level}>"
                 end
               end
               MACROS_RE = /(
                             (!)?                        # escaping
                             (
                             \{\{                        # opening tag
                             ([\w]+)                     # macro name
                             (\(([^\n\r]*?)\))?          # optional arguments
                             ([\n\r].*?[\n\r])?          # optional block of text
                             \}\}                        # closing tag
                             )
                            )/mx unless const_defined?(:MACROS_RE)
               MACRO_SUB_RE = /(
                               \{\{
                               macro\((\d+)\)
                               \}\}
                               )/x unless const_defined?(:MACRO_SUB_RE)
               # Extracts macros from text
               def catch_macros(text)
                 macros = {}
                 text.gsub!(MACROS_RE) do
                   all, macro = $1, $4.downcase
                   if macro_exists?(macro) || all =~ MACRO_SUB_RE
                     index = macros.size
                     macros[index] = all
                     "{{macro(#{index})}}"
                   else
                     all
                   end
                 end
                 macros
               end
               # Executes and replaces macros in text
               def inject_macros(text, obj, macros, execute=true)
                 text.gsub!(MACRO_SUB_RE) do
                   all, index = $1, $2.to_i
                   orig = macros.delete(index)
                   if execute && orig && orig =~ MACROS_RE
                     esc, all, macro, args, block = $2, $3, $4.downcase, $6.to_s, $7.try(:strip)
                     if esc.nil?
                       h(exec_macro(macro, obj, args, block) || all)
                     else
                       h(all)
                     end
                   elsif orig
                     h(orig)
                   else
                     h(all)
                   end
                 end
               end
               TOC_RE = /<p>\{\{([<>]?)toc\}\}<\/p>/i unless const_defined?(:TOC_RE)
               # Renders the TOC with given headings
               def replace_toc(text, headings)
                 text.gsub!(TOC_RE) do
                   # Keep only the 4 first levels
                   headings = headings.select{|level, anchor, item| level <= 4}
                   if headings.empty?
                     ''
                   else
                     div_class = 'toc'
                     div_class << ' right' if $1 == '>'
                     div_class << ' left' if $1 == '<'
                     out = "<ul class=\"#{div_class}\"><li>"
                     root = headings.map(&:first).min
                     current = root
                     started = false
                     headings.each do |level, anchor, item|
                       if level > current
                         out << '<ul><li>' * (level - current)
                       elsif level < current
                         out << "</li></ul>\n" * (current - level) + "</li><li>"
                       elsif started
                         out << '</li><li>'
                       end
                       out << "<a href=\"##{anchor}\">#{item}</a>"
                       current = level
                       started = true
                     end
                     out << '</li></ul>' * (current - root)
                     out << '</li></ul>'
                   end
                 end
               end
               # Same as Rails' simple_format helper without using paragraphs
               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
                   html_safe
               end
               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
               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
               def labelled_form_for(*args, &proc)
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 if args.first.is_a?(Symbol)
                   options.merge!(:as => args.shift)
                 end
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                 form_for(*args, &proc)
               end
               def labelled_fields_for(*args, &proc)
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                 fields_for(*args, &proc)
               end
               def labelled_remote_form_for(*args, &proc)
                 ActiveSupport::Deprecation.warn "ApplicationHelper#labelled_remote_form_for is deprecated and will be removed in Redmine 2.2."
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder, :remote => true})
                 form_for(*args, &proc)
               end
               def error_messages_for(*objects)
                 html = ""
                 objects = objects.map {|o| o.is_a?(String) ? instance_variable_get("@#{o}") : o}.compact
                 errors = objects.map {|o| o.errors.full_messages}.flatten
                 if errors.any?
                   html << "<div id='errorExplanation'><ul>\n"
                   errors.each do |error|
                     html << "<li>#{h error}</li>\n"
                   end
                   html << "</ul></div>\n"
                 end
                 html.html_safe
               end
               def delete_link(url, options={})
                 options = {
                   :method => :delete,
                   :data => {:confirm => l(:text_are_you_sure)},
                   :class => 'icon icon-del'
                 }.merge(options)
                 link_to l(:button_delete), url, options
               end
               def preview_link(url, form, target='preview', options={})
                 content_tag 'a', l(:label_preview), {
                     :href => "#",
                     :onclick => %|submitPreview("#{escape_javascript url_for(url)}", "#{escape_javascript form}", "#{escape_javascript target}"); return false;|,
                     :accesskey => accesskey(:preview)
                   }.merge(options)
               end
               def link_to_function(name, function, html_options={})
                 content_tag(:a, name, {:href => '#', :onclick => "#{function}; return false;"}.merge(html_options))
               end
+              # Helper to render JSON in views
+              def raw_json(arg)
+                arg.to_json.to_s.gsub('/', '\/').html_safe
+              end
               def back_url
                 url = params[:back_url]
                 if url.nil? && referer = request.env['HTTP_REFERER']
                   url = CGI.unescape(referer.to_s)
                 end
                 url
               end
               def back_url_hidden_field_tag
                 url = back_url
                 hidden_field_tag('back_url', url, :id => nil) unless url.blank?
               end
               def check_all_links(form_name)
                 link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
                 " | ".html_safe +
                 link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
               end
               def progress_bar(pcts, options={})
                 pcts = [pcts, pcts] unless pcts.is_a?(Array)
                 pcts = pcts.collect(&:round)
                 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]}%;", :class => 'closed') : ''.html_safe) +
                     (pcts[1] > 0 ? content_tag('td', '', :style => "width: #{pcts[1]}%;", :class => 'done') : ''.html_safe) +
                     (pcts[2] > 0 ? content_tag('td', '', :style => "width: #{pcts[2]}%;", :class => 'todo') : ''.html_safe)
                   ), :class => 'progress', :style => "width: #{width};").html_safe +
                   content_tag('p', legend, :class => 'pourcent').html_safe
               end
               def checked_image(checked=true)
                 if checked
                   image_tag 'toggle_check.png'
                 end
               end
               def context_menu(url)
                 unless @context_menu_included
                   content_for :header_tags do
                     javascript_include_tag('context_menu') +
                       stylesheet_link_tag('context_menu')
                   end
                   if l(:direction) == 'rtl'
                     content_for :header_tags do
                       stylesheet_link_tag('context_menu_rtl')
                     end
                   end
                   @context_menu_included = true
                 end
                 javascript_tag "contextMenuInit('#{ url_for(url) }')"
               end
               def calendar_for(field_id)
                 include_calendar_headers_tags
                 javascript_tag("$(function() { $('##{field_id}').datepicker(datepickerOptions); });")
               end
               def include_calendar_headers_tags
                 unless @calendar_headers_tags_included
                   @calendar_headers_tags_included = true
                   content_for :header_tags do
                     start_of_week = Setting.start_of_week
                     start_of_week = l(:general_first_day_of_week, :default => '1') if start_of_week.blank?
                     # Redmine uses 1..7 (monday..sunday) in settings and locales
                     # JQuery uses 0..6 (sunday..saturday), 7 needs to be changed to 0
                     start_of_week = start_of_week.to_i % 7
                     tags = javascript_tag(
                                "var datepickerOptions={dateFormat: 'yy-mm-dd', firstDay: #{start_of_week}, " +
                                  "showOn: 'button', buttonImageOnly: true, buttonImage: '" +
                                  path_to_image('/images/calendar.png') +
                                  "', showButtonPanel: true};")
                     jquery_locale = l('jquery.locale', :default => current_language.to_s)
                     unless jquery_locale == 'en'
                       tags << javascript_include_tag("i18n/jquery.ui.datepicker-#{jquery_locale}.js")
                     end
                     tags
                   end
                 end
               end
               # Overrides Rails' stylesheet_link_tag with themes and plugins support.
               # Examples:
               #   stylesheet_link_tag('styles') # => picks styles.css from the current theme or defaults
               #   stylesheet_link_tag('styles', :plugin => 'foo) # => picks styles.css from plugin's assets
               #
               def stylesheet_link_tag(*sources)
                 options = sources.last.is_a?(Hash) ? sources.pop : {}
                 plugin = options.delete(:plugin)
                 sources = sources.map do |source|
                   if plugin
                     "/plugin_assets/#{plugin}/stylesheets/#{source}"
                   elsif current_theme && current_theme.stylesheets.include?(source)
                     current_theme.stylesheet_path(source)
                   else
                     source
                   end
                 end
                 super sources, options
               end
               # Overrides Rails' image_tag with themes and plugins support.
               # Examples:
               #   image_tag('image.png') # => picks image.png from the current theme or defaults
               #   image_tag('image.png', :plugin => 'foo) # => picks image.png from plugin's assets
               #
               def image_tag(source, options={})
                 if plugin = options.delete(:plugin)
                   source = "/plugin_assets/#{plugin}/images/#{source}"
                 elsif current_theme && current_theme.images.include?(source)
                   source = current_theme.image_path(source)
                 end
                 super source, options
               end
               # Overrides Rails' javascript_include_tag with plugins support
               # Examples:
               #   javascript_include_tag('scripts') # => picks scripts.js from defaults
               #   javascript_include_tag('scripts', :plugin => 'foo) # => picks scripts.js from plugin's assets
               #
               def javascript_include_tag(*sources)
                 options = sources.last.is_a?(Hash) ? sources.pop : {}
                 if plugin = options.delete(:plugin)
                   sources = sources.map do |source|
                     if plugin
                       "/plugin_assets/#{plugin}/javascripts/#{source}"
                     else
                       source
                     end
                   end
                 end
                 super sources, options
               end
               def content_for(name, content = nil, &block)
                 @has_content ||= {}
                 @has_content[name] = true
                 super(name, content, &block)
               end
               def has_content?(name)
                 (@has_content && @has_content[name]) || false
               end
               def sidebar_content?
                 has_content?(:sidebar) || view_layouts_base_sidebar_hook_response.present?
               end
               def view_layouts_base_sidebar_hook_response
                 @view_layouts_base_sidebar_hook_response ||= call_hook(:view_layouts_base_sidebar)
               end
               def email_delivery_enabled?
                 !!ActionMailer::Base.perform_deliveries
               end
               # 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>')
               def avatar(user, options = { })
                 if Setting.gravatar_enabled?
                   options.merge!({:ssl => (request && request.ssl?), :default => Setting.gravatar_default})
                   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
                 else
                   ''
                 end
               end
               def sanitize_anchor_name(anchor)
                 if ''.respond_to?(:encoding) || RUBY_PLATFORM == 'java'
                   anchor.gsub(%r{[^\p{Word}\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                 else
                   # TODO: remove when ruby1.8 is no longer supported
                   anchor.gsub(%r{[^\w\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                 end
               end
               # Returns the javascript tags that are included in the html layout head
               def javascript_heads
                 tags = javascript_include_tag('jquery-1.7.2-ui-1.8.21-ujs-2.0.3', 'application')
                 unless User.current.pref.warn_on_leaving_unsaved == '0'
                   tags << "\n".html_safe + javascript_tag("$(window).load(function(){ warnLeavingUnsaved('#{escape_javascript l(:text_warn_on_leaving_unsaved)}'); });")
                 end
                 tags
               end
               def favicon
                 "<link rel='shortcut icon' href='#{image_path('/favicon.ico')}' />".html_safe
               end
               def robot_exclusion_tag
                 '<meta name="robots" content="noindex,follow,noarchive" />'.html_safe
               end
               # Returns true if arg is expected in the API response
               def include_in_api_response?(arg)
                 unless @included_in_api_response
                   param = params[:include]
                   @included_in_api_response = param.is_a?(Array) ? param.collect(&:to_s) : param.to_s.split(',')
                   @included_in_api_response.collect!(&:strip)
                 end
                 @included_in_api_response.include?(arg.to_s)
               end
               # Returns options or nil if nometa param or X-Redmine-Nometa header
               # was set in the request
               def api_meta(options)
                 if params[:nometa].present? || request.headers['X-Redmine-Nometa']
                   # compatibility mode for activeresource clients that raise
                   # an error when unserializing an array with attributes
                   nil
                 else
                   options
                 end
               end
               private
               def wiki_helper
                 helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                 extend helper
                 return self
               end
               def link_to_content_update(text, url_params = {}, html_options = {})
                 link_to(text, url_params, html_options)
               end
             end

app/views/queries/_filters.html.erb +5 -5

             <%= javascript_tag do %>
-            var operatorLabels = <%= raw Query.operators_labels.to_json %>;
+            var operatorLabels = <%= raw_json Query.operators_labels %>;
-            var operatorByType = <%= raw Query.operators_by_filter_type.to_json %>;
+            var operatorByType = <%= raw_json Query.operators_by_filter_type %>;
-            var availableFilters = <%= raw query.available_filters_as_json.to_json %>;
+            var availableFilters = <%= raw_json query.available_filters_as_json %>;
-            var labelDayPlural = "<%= raw escape_javascript(l(:label_day_plural)) %>";
+            var labelDayPlural = <%= raw_json l(:label_day_plural) %>;
             $(document).ready(function(){
               initFilters();
               <% query.filters.each do |field, options| %>
-              addFilter("<%= field %>", <%= raw query.operator_for(field).to_json %>, <%= raw query.values_for(field).to_json %>);
+              addFilter("<%= field %>", <%= raw_json query.operator_for(field) %>, <%= raw_json query.values_for(field) %>);
               <% end %>
             });
             <% end %>
             <table style="width:100%">
             <tr>
             <td>
             <table id="filters-table">
             </table>
             </td>
             <td class="add-filter">
             <%= label_tag('add_filter_select', l(:label_filter_add)) %>
             <%= select_tag 'add_filter_select', filters_options_for_select(query), :name => nil %>
             </td>
             </tr>
             </table>
             <%= hidden_field_tag 'f[]', '' %>
             <% include_calendar_headers_tags %>

public/javascripts/application.js +6 -6

             /* Redmine - project management software
                Copyright (C) 2006-2012  Jean-Philippe Lang */
             function checkAll(id, checked) {
               if (checked) {
                 $('#'+id).find('input[type=checkbox]').attr('checked', true);
               } else {
                 $('#'+id).find('input[type=checkbox]').removeAttr('checked');
               }
             }
             function toggleCheckboxesBySelector(selector) {
               var all_checked = true;
               $(selector).each(function(index) {
                 if (!$(this).is(':checked')) { all_checked = false; }
               });
               $(selector).attr('checked', !all_checked)
             }
             function showAndScrollTo(id, focus) {
               $('#'+id).show();
               if (focus!=null) {
                 $('#'+focus).focus();
               }
               $('html, body').animate({scrollTop: $('#'+id).offset().top}, 100);
             }
             function toggleRowGroup(el) {
               var tr = $(el).parents('tr').first();
               var n = tr.next();
               tr.toggleClass('open');
               while (n.length && !n.hasClass('group')) {
                 n.toggle();
                 n = n.next('tr');
               }
             }
             function collapseAllRowGroups(el) {
               var tbody = $(el).parents('tbody').first();
               tbody.children('tr').each(function(index) {
                 if ($(this).hasClass('group')) {
                   $(this).removeClass('open');
                 } else {
                   $(this).hide();
                 }
               });
             }
             function expandAllRowGroups(el) {
               var tbody = $(el).parents('tbody').first();
               tbody.children('tr').each(function(index) {
                 if ($(this).hasClass('group')) {
                   $(this).addClass('open');
                 } else {
                   $(this).show();
                 }
               });
             }
             function toggleAllRowGroups(el) {
               var tr = $(el).parents('tr').first();
               if (tr.hasClass('open')) {
                 collapseAllRowGroups(el);
               } else {
                 expandAllRowGroups(el);
               }
             }
             function toggleFieldset(el) {
               var fieldset = $(el).parents('fieldset').first();
               fieldset.toggleClass('collapsed');
               fieldset.children('div').toggle();
             }
             function hideFieldset(el) {
               var fieldset = $(el).parents('fieldset').first();
               fieldset.toggleClass('collapsed');
               fieldset.children('div').hide();
             }
             function initFilters(){
               $('#add_filter_select').change(function(){
                 addFilter($(this).val(), '', []);
               });
               $('#filters-table td.field input[type=checkbox]').each(function(){
                 toggleFilter($(this).val());
               });
               $('#filters-table td.field input[type=checkbox]').live('click',function(){
                 toggleFilter($(this).val());
               });
               $('#filters-table .toggle-multiselect').live('click',function(){
                 toggleMultiSelect($(this).siblings('select'));
               });
               $('#filters-table input[type=text]').live('keypress', function(e){
                 if (e.keyCode == 13) submit_query_form("query_form");
               });
             }
             function addFilter(field, operator, values) {
               var fieldId = field.replace('.', '_');
               var tr = $('#tr_'+fieldId);
               if (tr.length > 0) {
                 tr.show();
               } else {
                 buildFilterRow(field, operator, values);
               }
               $('#cb_'+fieldId).attr('checked', true);
               toggleFilter(field);
               $('#add_filter_select').val('').children('option').each(function(){
                 if ($(this).attr('value') == field) {
                   $(this).attr('disabled', true);
                 }
               });
             }
             function buildFilterRow(field, operator, values) {
               var fieldId = field.replace('.', '_');
               var filterTable = $("#filters-table");
               var filterOptions = availableFilters[field];
               var operators = operatorByType[filterOptions['type']];
               var filterValues = filterOptions['values'];
               var i, select;
               var tr = $('<tr class="filter">').attr('id', 'tr_'+fieldId).html(
                 '<td class="field"><input checked="checked" id="cb_'+fieldId+'" name="f[]" value="'+field+'" type="checkbox"><label for="cb_'+fieldId+'"> '+filterOptions['name']+'</label></td>' +
                 '<td class="operator"><select id="operators_'+fieldId+'" name="op['+field+']"></td>' +
                 '<td class="values"></td>'
               );
               filterTable.append(tr);
               select = tr.find('td.operator select');
               for (i=0;i<operators.length;i++){
                 var option = $('<option>').val(operators[i]).text(operatorLabels[operators[i]]);
                 if (operators[i] == operator) {option.attr('selected', true)};
                 select.append(option);
               }
               select.change(function(){toggleOperator(field)});
               switch (filterOptions['type']){
               case "list":
               case "list_optional":
               case "list_status":
               case "list_subprojects":
                 tr.find('td.values').append(
                   '<span style="display:none;"><select class="value" id="values_'+fieldId+'_1" name="v['+field+'][]"></select>' +
                   ' <span class="toggle-multiselect">&nbsp;</span></span>'
                 );
                 select = tr.find('td.values select');
                 if (values.length > 1) {select.attr('multiple', true)};
                 for (i=0;i<filterValues.length;i++){
                   var filterValue = filterValues[i];
                   var option = $('<option>');
                   if ($.isArray(filterValue)) {
                     option.val(filterValue[1]).text(filterValue[0]);
                     if ($.inArray(filterValue[1], values) > -1) {option.attr('selected', true);}
                   } else {
                     option.val(filterValue).text(filterValue);
                     if ($.inArray(filterValue, values) > -1) {option.attr('selected', true);}
                   }
                   select.append(option);
                 }
                 break;
               case "date":
               case "date_past":
                 tr.find('td.values').append(
-                  '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="10" class="value date_value" value="'+values[0]+'" /></span>' +
+                  '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="10" class="value date_value" /></span>' +
-                  ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="10" class="value date_value" value="'+values[1]+'" /></span>' +
+                  ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="10" class="value date_value" /></span>' +
-                  ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="3" class="value" value="'+values[0]+'" /> '+labelDayPlural+'</span>'
+                  ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="3" class="value" /> '+labelDayPlural+'</span>'
                 );
                 $('#values_'+fieldId+'_1').val(values[0]).datepicker(datepickerOptions);
                 $('#values_'+fieldId+'_2').val(values[1]).datepicker(datepickerOptions);
                 $('#values_'+fieldId).val(values[0]);
                 break;
               case "string":
               case "text":
                 tr.find('td.values').append(
-                  '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="30" class="value" value="'+values[0]+'" /></span>'
+                  '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'" size="30" class="value" /></span>'
                 );
                 $('#values_'+fieldId).val(values[0]);
                 break;
               case "integer":
               case "float":
                 tr.find('td.values').append(
-                  '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="6" class="value" value="'+values[0]+'" /></span>' +
+                  '<span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_1" size="6" class="value" /></span>' +
-                  ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="6" class="value" value="'+values[1]+'" /></span>'
+                  ' <span style="display:none;"><input type="text" name="v['+field+'][]" id="values_'+fieldId+'_2" size="6" class="value" /></span>'
                 );
                 $('#values_'+fieldId+'_1').val(values[0]);
                 $('#values_'+fieldId+'_2').val(values[1]);
                 break;
               }
             }
             function toggleFilter(field) {
               var fieldId = field.replace('.', '_');
               if ($('#cb_' + fieldId).is(':checked')) {
                 $("#operators_" + fieldId).show().removeAttr('disabled');
                 toggleOperator(field);
               } else {
                 $("#operators_" + fieldId).hide().attr('disabled', true);
                 enableValues(field, []);
               }
             }
             function enableValues(field, indexes) {
               var fieldId = field.replace('.', '_');
               $('#tr_'+fieldId+' td.values .value').each(function(index) {
                 if ($.inArray(index, indexes) >= 0) {
                   $(this).removeAttr('disabled');
                   $(this).parents('span').first().show();
                 } else {
                   $(this).val('');
                   $(this).attr('disabled', true);
                   $(this).parents('span').first().hide();
                 }
                 if ($(this).hasClass('group')) {
                   $(this).addClass('open');
                 } else {
                   $(this).show();
                 }
               });
             }
             function toggleOperator(field) {
               var fieldId = field.replace('.', '_');
               var operator = $("#operators_" + fieldId);
               switch (operator.val()) {
                 case "!*":
                 case "*":
                 case "t":
                 case "w":
                 case "o":
                 case "c":
                   enableValues(field, []);
                   break;
                 case "><":
                   enableValues(field, [0,1]);
                   break;
                 case "<t+":
                 case ">t+":
                 case "t+":
                 case ">t-":
                 case "<t-":
                 case "t-":
                   enableValues(field, [2]);
                   break;
                 default:
                   enableValues(field, [0]);
                   break;
               }
             }
             function toggleMultiSelect(el) {
               if (el.attr('multiple')) {
                 el.removeAttr('multiple');
               } else {
                 el.attr('multiple', true);
               }
             }
             function submit_query_form(id) {
               selectAllOptions("selected_columns");
               $('#'+id).submit();
             }
             var fileFieldCount = 1;
             function addFileField() {
               var fields = $('#attachments_fields');
               if (fields.children().length >= 10) return false;
               fileFieldCount++;
               var s = fields.children('span').first().clone();
               s.children('input.file').attr('name', "attachments[" + fileFieldCount + "][file]").val('');
               s.children('input.description').attr('name', "attachments[" + fileFieldCount + "][description]").val('');
               fields.append(s);
             }
             function removeFileField(el) {
               var fields = $('#attachments_fields');
               var s = $(el).parents('span').first();
               if (fields.children().length > 1) {
                 s.remove();
               } else {
                 s.children('input.file').val('');
                 s.children('input.description').val('');
               }
             }
             function checkFileSize(el, maxSize, message) {
               var files = el.files;
               if (files) {
                 for (var i=0; i<files.length; i++) {
                   if (files[i].size > maxSize) {
                     alert(message);
                     el.value = "";
                   }
                 }
               }
             }
             function showTab(name) {
               $('div#content .tab-content').hide();
               $('div.tabs a').removeClass('selected');
               $('#tab-content-' + name).show();
               $('#tab-' + name).addClass('selected');
               return false;
             }
             function moveTabRight(el) {
               var lis = $(el).parents('div.tabs').first().find('ul').children();
               var tabsWidth = 0;
               var i = 0;
               lis.each(function(){
                 if ($(this).is(':visible')) {
                   tabsWidth += $(this).width() + 6;
                 }
               });
               if (tabsWidth < $(el).parents('div.tabs').first().width() - 60) { return; }
               while (i<lis.length && !lis.eq(i).is(':visible')) { i++; }
               lis.eq(i).hide();
             }
             function moveTabLeft(el) {
               var lis = $(el).parents('div.tabs').first().find('ul').children();
               var i = 0;
               while (i<lis.length && !lis.eq(i).is(':visible')) { i++; }
               if (i>0) {
                 lis.eq(i-1).show();
               }
             }
             function displayTabsButtons() {
               var lis;
               var tabsWidth = 0;
               var el;
               $('div.tabs').each(function() {
                 el = $(this);
                 lis = el.find('ul').children();
                 lis.each(function(){
                   if ($(this).is(':visible')) {
                     tabsWidth += $(this).width() + 6;
                   }
                 });
                 if ((tabsWidth < el.width() - 60) && (lis.first().is(':visible'))) {
                   el.find('div.tabs-buttons').hide();
                 } else {
                   el.find('div.tabs-buttons').show();
                 }
               });
             }
             function setPredecessorFieldsVisibility() {
               var relationType = $('#relation_relation_type');
               if (relationType.val() == "precedes" || relationType.val() == "follows") {
                 $('#predecessor_fields').show();
               } else {
                 $('#predecessor_fields').hide();
               }
             }
             function showModal(id, width) {
               var el = $('#'+id).first();
               if (el.length == 0 || el.is(':visible')) {return;}
               var title = el.find('h3.title').text();
               el.dialog({
                 width: width,
                 modal: true,
                 resizable: false,
                 dialogClass: 'modal',
                 title: title
               });
               el.find("input[type=text], input[type=submit]").first().focus();
             }
             function hideModal(el) {
               var modal;
               if (el) {
                 modal = $(el).parents('.ui-dialog-content');
               } else {
                 modal = $('#ajax-modal');
               }
               modal.dialog("close");
             }
             function submitPreview(url, form, target) {
               $.ajax({
                 url: url,
                 type: 'post',
                 data: $('#'+form).serialize(),
                 success: function(data){
                   $('#'+target).html(data);
                 }
               });
             }
             function collapseScmEntry(id) {
               $('.'+id).each(function() {
                 if ($(this).hasClass('open')) {
                   collapseScmEntry($(this).attr('id'));
                 }
                 $(this).hide();
               });
               $('#'+id).removeClass('open');
             }
             function expandScmEntry(id) {
               $('.'+id).each(function() {
                 $(this).show();
                 if ($(this).hasClass('loaded') && !$(this).hasClass('collapsed')) {
                   expandScmEntry($(this).attr('id'));
                 }
               });
               $('#'+id).addClass('open');
             }
             function scmEntryClick(id, url) {
                 el = $('#'+id);
                 if (el.hasClass('open')) {
                     collapseScmEntry(id);
                     el.addClass('collapsed');
                     return false;
                 } else if (el.hasClass('loaded')) {
                     expandScmEntry(id);
                     el.removeClass('collapsed');
                     return false;
                 }
                 if (el.hasClass('loading')) {
                     return false;
                 }
                 el.addClass('loading');
                 $.ajax({
                   url: url,
                   success: function(data){
                     el.after(data);
                     el.addClass('open').addClass('loaded').removeClass('loading');
                   }
                 });
                 return true;
             }
             function randomKey(size) {
               var chars = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z');
               var key = '';
               for (i = 0; i < size; i++) {
                 key += chars[Math.floor(Math.random() * chars.length)];
               }
               return key;
             }
             // Can't use Rails' remote select because we need the form data
             function updateIssueFrom(url) {
               $.ajax({
                 url: url,
                 type: 'post',
                 data: $('#issue-form').serialize()
               });
             }
             function updateBulkEditFrom(url) {
               $.ajax({
                 url: url,
                 type: 'post',
                 data: $('#bulk_edit_form').serialize()
               });
             }
             function observeAutocompleteField(fieldId, url) {
               $('#'+fieldId).autocomplete({
                 source: url,
                 minLength: 2,
               });
             }
             function observeSearchfield(fieldId, targetId, url) {
               $('#'+fieldId).each(function() {
                 var $this = $(this);
                 $this.attr('data-value-was', $this.val());
                 var check = function() {
                   var val = $this.val();
                   if ($this.attr('data-value-was') != val){
                     $this.attr('data-value-was', val);
                     $.ajax({
                       url: url,
                       type: 'get',
                       data: {q: $this.val()},
                       success: function(data){ $('#'+targetId).html(data); },
                       beforeSend: function(){ $this.addClass('ajax-loading'); },
                       complete: function(){ $this.removeClass('ajax-loading'); }
                     });
                   }
                 };
                 var reset = function() {
                   if (timer) {
                     clearInterval(timer);
                     timer = setInterval(check, 300);
                   }
                 };
                 var timer = setInterval(check, 300);
                 $this.bind('keyup click mousemove', reset);
               });
             }
             function observeProjectModules() {
               var f = function() {
                 /* Hides trackers and issues custom fields on the new project form when issue_tracking module is disabled */
                 if ($('#project_enabled_module_names_issue_tracking').attr('checked')) {
                   $('#project_trackers').show();
                 }else{
                   $('#project_trackers').hide();
                 }
               };
               $(window).load(f);
               $('#project_enabled_module_names_issue_tracking').change(f);
             }
             function initMyPageSortable(list, url) {
               $('#list-'+list).sortable({
                 connectWith: '.block-receiver',
                 tolerance: 'pointer',
                 update: function(){
                   $.ajax({
                     url: url,
                     type: 'post',
                     data: {'blocks': $.map($('#list-'+list).children(), function(el){return $(el).attr('id');})}
                   });
                 }
               });
               $("#list-top, #list-left, #list-right").disableSelection();
             }
             var warnLeavingUnsavedMessage;
             function warnLeavingUnsaved(message) {
               warnLeavingUnsavedMessage = message;
               $('form').submit(function(){
                 $('textarea').removeData('changed');
               });
               $('textarea').change(function(){
                 $(this).data('changed', 'changed');
               });
               window.onbeforeunload = function(){
                 var warn = false;
                 $('textarea').blur().each(function(){
                   if ($(this).data('changed')) {
                     warn = true;
                   }
                 });
                 if (warn) {return warnLeavingUnsavedMessage;}
               };
             };
             $(document).ready(function(){
               $('#ajax-indicator').bind('ajaxSend', function(){
                 if ($('.ajax-loading').length == 0) {
                   $('#ajax-indicator').show();
                 }
               });
               $('#ajax-indicator').bind('ajaxStop', function(){
                 $('#ajax-indicator').hide();
               });
             });
             function hideOnLoad() {
               $('.hol').hide();
             }
             function addFormObserversForDoubleSubmit() {
               $('form[method=post]').each(function() {
                 if (!$(this).hasClass('multiple-submit')) {
                   $(this).submit(function(form_submission) {
                     if ($(form_submission.target).attr('data-submitted')) {
                       form_submission.preventDefault();
                     } else {
                       $(form_submission.target).attr('data-submitted', true);
                     }
                   });
                 }
               });
             }
             $(document).ready(hideOnLoad);
             $(document).ready(addFormObserversForDoubleSubmit);

test/functional/queries_controller_test.rb +8 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class QueriesControllerTest < ActionController::TestCase
               fixtures :projects, :users, :members, :member_roles, :roles, :trackers, :issue_statuses, :issue_categories, :enumerations, :issues, :custom_fields, :custom_values, :queries
               def setup
                 User.current = nil
               end
               def test_new_project_query
                 @request.session[:user_id] = 2
                 get :new, :project_id => 1
                 assert_response :success
                 assert_template 'new'
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query[is_public]',
                                                              :checked => nil }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                                                              :disabled => nil }
                 assert_select 'select[name=?]', 'c[]' do
                   assert_select 'option[value=tracker]'
                   assert_select 'option[value=subject]'
                 end
               end
               def test_new_global_query
                 @request.session[:user_id] = 2
                 get :new
                 assert_response :success
                 assert_template 'new'
                 assert_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                                 :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                                                              :disabled => nil }
               end
               def test_new_on_invalid_project
                 @request.session[:user_id] = 2
                 get :new, :project_id => 'invalid'
                 assert_response 404
               end
               def test_create_project_public_query
                 @request.session[:user_id] = 2
                 post :create,
                      :project_id => 'ecookbook',
                      :default_columns => '1',
                      :f => ["status_id", "assigned_to_id"],
                      :op => {"assigned_to_id" => "=", "status_id" => "o"},
                      :v => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
                      :query => {"name" => "test_new_project_public_query", "is_public" => "1"}
                 q = Query.find_by_name('test_new_project_public_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :query_id => q
                 assert q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_create_project_private_query
                 @request.session[:user_id] = 3
                 post :create,
                      :project_id => 'ecookbook',
                      :default_columns => '1',
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
                      :query => {"name" => "test_new_project_private_query", "is_public" => "1"}
                 q = Query.find_by_name('test_new_project_private_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :query_id => q
                 assert !q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_create_global_private_query_with_custom_columns
                 @request.session[:user_id] = 3
                 post :create,
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["me"], "status_id" => ["1"]},
                      :query => {"name" => "test_new_global_private_query", "is_public" => "1"},
                      :c => ["", "tracker", "subject", "priority", "category"]
                 q = Query.find_by_name('test_new_global_private_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => nil, :query_id => q
                 assert !q.is_public?
                 assert !q.has_default_columns?
                 assert_equal [:tracker, :subject, :priority, :category], q.columns.collect {|c| c.name}
                 assert q.valid?
               end
               def test_create_global_query_with_custom_filters
                 @request.session[:user_id] = 3
                 post :create,
                      :fields => ["assigned_to_id"],
                      :operators => {"assigned_to_id" => "="},
                      :values => { "assigned_to_id" => ["me"]},
                      :query => {"name" => "test_new_global_query"}
                 q = Query.find_by_name('test_new_global_query')
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => nil, :query_id => q
                 assert !q.has_filter?(:status_id)
                 assert_equal ['assigned_to_id'], q.filters.keys
                 assert q.valid?
               end
               def test_create_with_sort
                 @request.session[:user_id] = 1
                 post :create,
                      :default_columns => '1',
                      :operators => {"status_id" => "o"},
                      :values => {"status_id" => ["1"]},
                      :query => {:name => "test_new_with_sort",
                                 :is_public => "1",
                                 :sort_criteria => {"0" => ["due_date", "desc"], "1" => ["tracker", ""]}}
                 query = Query.find_by_name("test_new_with_sort")
                 assert_not_nil query
                 assert_equal [['due_date', 'desc'], ['tracker', 'asc']], query.sort_criteria
               end
               def test_create_with_failure
                 @request.session[:user_id] = 2
                 assert_no_difference '::Query.count' do
                   post :create, :project_id => 'ecookbook', :query => {:name => ''}
                 end
                 assert_response :success
                 assert_template 'new'
                 assert_select 'input[name=?]', 'query[name]'
               end
               def test_edit_global_public_query
                 @request.session[:user_id] = 1
                 get :edit, :id => 4
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query[is_public]',
                                                              :checked => 'checked' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                                                              :disabled => 'disabled' }
               end
               def test_edit_global_private_query
                 @request.session[:user_id] = 3
                 get :edit, :id => 3
                 assert_response :success
                 assert_template 'edit'
                 assert_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                                 :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => 'checked',
                                                              :disabled => 'disabled' }
               end
               def test_edit_project_private_query
                 @request.session[:user_id] = 3
                 get :edit, :id => 2
                 assert_response :success
                 assert_template 'edit'
                 assert_no_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                                 :name => 'query[is_public]' }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                                                              :disabled => nil }
               end
               def test_edit_project_public_query
                 @request.session[:user_id] = 2
                 get :edit, :id => 1
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query[is_public]',
                                                              :checked => 'checked'
                                                               }
                 assert_tag :tag => 'input', :attributes => { :type => 'checkbox',
                                                              :name => 'query_is_for_all',
                                                              :checked => nil,
                                                              :disabled => 'disabled' }
               end
               def test_edit_sort_criteria
                 @request.session[:user_id] = 1
                 get :edit, :id => 5
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :tag => 'select', :attributes => { :name => 'query[sort_criteria][0][]' },
                                              :child => { :tag => 'option', :attributes => { :value => 'priority',
                                                                                             :selected => 'selected' } }
                 assert_tag :tag => 'select', :attributes => { :name => 'query[sort_criteria][0][]' },
                                              :child => { :tag => 'option', :attributes => { :value => 'desc',
                                                                                             :selected => 'selected' } }
               end
               def test_edit_invalid_query
                 @request.session[:user_id] = 2
                 get :edit, :id => 99
                 assert_response 404
               end
               def test_udpate_global_private_query
                 @request.session[:user_id] = 3
                 put :update,
                      :id => 3,
                      :default_columns => '1',
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["me"], "status_id" => ["1"]},
                      :query => {"name" => "test_edit_global_private_query", "is_public" => "1"}
                 assert_redirected_to :controller => 'issues', :action => 'index', :query_id => 3
                 q = Query.find_by_name('test_edit_global_private_query')
                 assert !q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_update_global_public_query
                 @request.session[:user_id] = 1
                 put :update,
                      :id => 4,
                      :default_columns => '1',
                      :fields => ["status_id", "assigned_to_id"],
                      :operators => {"assigned_to_id" => "=", "status_id" => "o"},
                      :values => { "assigned_to_id" => ["1"], "status_id" => ["1"]},
                      :query => {"name" => "test_edit_global_public_query", "is_public" => "1"}
                 assert_redirected_to :controller => 'issues', :action => 'index', :query_id => 4
                 q = Query.find_by_name('test_edit_global_public_query')
                 assert q.is_public?
                 assert q.has_default_columns?
                 assert q.valid?
               end
               def test_update_with_failure
                 @request.session[:user_id] = 1
                 put :update, :id => 4, :query => {:name => ''}
                 assert_response :success
                 assert_template 'edit'
               end
               def test_destroy
                 @request.session[:user_id] = 2
                 delete :destroy, :id => 1
                 assert_redirected_to :controller => 'issues', :action => 'index', :project_id => 'ecookbook', :set_filter => 1, :query_id => nil
                 assert_nil Query.find_by_id(1)
               end
+              def test_backslash_should_be_escaped_in_filters
+                @request.session[:user_id] = 2
+                get :new, :subject => 'foo/bar'
+                assert_response :success
+                assert_template 'new'
+                assert_include 'addFilter("subject", "=", ["foo\/bar"]);', response.body
+              end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages