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 operatorByType = <%= raw Query.operators_by_filter_type.to_json %>;
-             var availableFilters = <%= raw query.available_filters_as_json.to_json %>;
-             var labelDayPlural = "<%= raw escape_javascript(l(:label_day_plural)) %>";
+             var operatorLabels = <%= raw_json Query.operators_labels %>;
+             var operatorByType = <%= raw_json Query.operators_by_filter_type %>;
+             var availableFilters = <%= raw_json query.available_filters_as_json %>;
+             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+'_2" size="10" class="value date_value" value="'+values[1]+'" /></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+'_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" /></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+'_2" size="6" class="value" value="'+values[1]+'" /></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" /></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