SoundSoftware Code Site

# Redmine - project management software

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

  # 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

        subject = truncate(subject, :length => options[:truncate])

      end

    end

                                                 :class => issue.css_classes,

                                                 :title => title

    s << ": #{h subject}" if subject

    link_to(text, {:controller => 'repositories', :action => 'revision', :id => project, :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(

  # 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

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

    link_to name, {}, html_options

  end

  def format_activity_title(text)

    h(truncate_single_line(text, :length => 100))

  end

  def format_activity_day(date)

    date == Date.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 />")

  end

      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

    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},

        content << "</li>\n"

      end

      content << "</ul>\n"

    end

    content

  end

  # Renders flash messages

  def render_flash_messages

    s = ''

    end

    s

  end

  # Renders tabs and their content

  def render_tabs(tabs)

    if tabs.any?

      content_tag 'p', l(:label_no_data), :class => "nodata"

    end

  end

  # Renders the project quick-jump box

  def render_project_jump_box

    if projects.any?

      s = '<select onchange="if (this.value != \'\') { window.location = this.value; }">' +

            "<option value=''>#{ l(:label_jump_to_a_project) }</option>" +

      s

    end

  end

  def project_tree_options_for_select(projects, options = {})

    s = ''

    project_tree(projects) do |project, level|

    end

    s

  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 project_nested_ul(projects, &block)

    s = ''

    if projects.any?

        else

          ancestors.pop

          s << "</li>"

            ancestors.pop

            s << "</ul></li>\n"

          end

    end

    s

  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

  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

  def authoring(created, author, options={})

    l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created))

  end

  def time_tag(time)

    text = distance_of_time_in_words(Time.now, time)

    if @project

    page_param = options.delete(:page_param) || :page

    per_page_links = options.delete(:per_page_links)

    url_param = params.dup

    html = ''

    if paginator.current.previous

    end

    html << (pagination_links_each(paginator, options) do |n|

    end || '')

    if paginator.current.next

    end

    unless count.nil?

    html

  end

  def per_page_links(selected=nil)

    links = Setting.per_page_options_array.collect do |n|

    end

    links.size > 1 ? l(:label_display_per_page, links.join(', ')) : nil

  end

  def reorder_links(name, url)

    link_to(image_tag('2uparrow.png',   :alt => l(:label_sort_highest)), url.merge({"#{name}[move_to]" => 'highest'}), :method => :post, :title => l(:label_sort_highest)) +

    link_to(image_tag('1uparrow.png',   :alt => l(:label_sort_higher)),  url.merge({"#{name}[move_to]" => 'higher'}),  :method => :post, :title => l(:label_sort_higher)) +

    elements = args.flatten

    elements.any? ? content_tag('p', args.join(' » ') + ' » ', :class => 'breadcrumb') : nil

  end

  def other_formats_links(&block)

    concat('<p class="other-formats">' + l(:label_export_to))

    yield Redmine::Views::OtherFormatsBuilder.new(self)

    concat('</p>')

  end

  def page_header_title

    if @project.nil? || @project.new_record?

      h(Setting.app_title)

    else

      b = []

      if ancestors.any?

        root = ancestors.shift

        b << link_to_project(root, {:jump => current_menu_item}, :class => 'root')

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

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

    @parsed_headings = []

    text = parse_non_pre_blocks(text) do |text|

      [:parse_inline_attachments, :parse_wiki_links, :parse_redmine_links, :parse_headings].each do |method_name|

        send method_name, text, project, obj, attr, only_path, options

      end

    end

    if @parsed_headings.any?

      replace_toc(text, @parsed_headings)

    end

    text

  end

  def parse_non_pre_blocks(text)

    s = StringScanner.new(text)

    tags = []

    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 = nil

      text.gsub!(/src="([^\/"]+\.(bmp|gif|jpg|jpeg|png))"(\s+alt="([^"]*)")?/i) do |m|

        attachments ||= (options[:attachments] || obj.attachments).sort_by(&:created_on).reverse

        # search for the picture in attachments

        if found = attachments.detect { |att| att.filename.downcase == filename }

      end

    end

  end

  # Redmine links

  #

  # Examples:

      leading + (link || "#{project_prefix}#{prefix}#{sep}#{identifier}")

    end

  end

  HEADING_RE = /<h(1|2|3|4)( [^>]+)?>(.+?)<\/h(1|2|3|4)>/i unless const_defined?(:HEADING_RE)

  # 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 = $1.to_i, $2, $3

      item = strip_tags(content).strip

      anchor = item.gsub(%r{[^\w\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')

      @parsed_headings << [level, anchor, item]

    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

      ), :class => 'progress', :style => "width: #{width};") +

      content_tag('p', legend, :class => 'pourcent')

  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

          'Calendar._FD = 1;' # Monday

        when 7

          'Calendar._FD = 0;' # Sunday

        else

          '' # use language

        end

        javascript_include_tag('calendar/calendar') +

        javascript_include_tag("calendar/lang/calendar-#{current_language.to_s.downcase}.js") +

        javascript_include_tag('calendar/calendar-setup') +

        stylesheet_link_tag('calendar')

      end

      ''

    end

  end

  # Returns the javascript tags that are included in the html layout head

  def javascript_heads

    tags = javascript_include_tag(:defaults)

  def favicon

    "<link rel='shortcut icon' href='#{image_path('/favicon.ico')}' />"

  end

  # Returns true if arg is expected in the API response

  def include_in_api_response?(arg)

    unless @included_in_api_response

      options

    end

  end

  private

  def wiki_helper

    extend helper

    return self

  end

  end

end

#

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

  #   :author -- author names are not displayed if set to false

  def link_to_attachments(container, options = {})

    options.assert_valid_keys(:author)

    if container.attachments.any?

      options = {:deletable => container.attachments_deletable?, :author => true}.merge(options)

      render :partial => 'attachments/links', :locals => {:attachments => container.attachments, :options => options}

    end

  end

  def to_utf8(str)

    if str.respond_to?(:force_encoding)

      str.force_encoding('UTF-8')

    else

      return str if /\A[\r\n\t\x20-\x7e]*\Z/n.match(str) # for us-ascii

    end

    begin

      Iconv.conv('UTF-8//IGNORE', 'UTF-8', str + '  ')[0..-3]

    rescue Iconv::InvalidEncoding

  end

  def link_to_month(link_name, year, month, options={})

  end

end

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

    field_id = "#{name}_custom_field_values_#{custom_field.id}"

    field_format = Redmine::CustomFieldFormat.find_by_name(custom_field.field_format)

    when "date"

      text_field_tag(field_name, custom_value.value, :id => field_id, :size => 10) + 

      calendar_for(field_id)

      blank_option = custom_field.is_required? ?

                       (custom_field.default_value.blank? ? "<option value=\"\">--- #{l(:actionview_instancetag_blank_option)} ---</option>" : '') : 

                       '<option></option>'

    else

      text_field_tag(field_name, custom_value.value, :id => field_id)

    end

    custom_field_label_tag(name, custom_value) + custom_field_tag(name, custom_value)

  end

    field_name = "#{name}[custom_field_values][#{custom_field.id}]"

    field_id = "#{name}_custom_field_values_#{custom_field.id}"

    field_format = Redmine::CustomFieldFormat.find_by_name(custom_field.field_format)

      when "date"

        text_field_tag(field_name, '', :id => field_id, :size => 10) + 

        calendar_for(field_id)

                                                   [l(:general_text_yes), '1'],

                                                   [l(:general_text_no), '0']]), :id => field_id)

      when "list"

      else

        text_field_tag(field_name, '', :id => field_id)

    end

  end

  # Return an array of custom field formats which can be used in select_tag

  end

  # Renders the custom_values in api views

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

    case in_or_out

    when :in

      if gantt.zoom < 4

      else

        content_tag('span', l(:text_zoom_in), :class => 'icon icon-zoom-in')

      end

    when :out

      if gantt.zoom > 1

      else

        content_tag('span', l(:text_zoom_out), :class => 'icon icon-zoom-out')

      end

    end

  end

end

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

      "<strong>#{@cached_label_assigned_to}</strong>: #{issue.assigned_to}<br />" +

      "<strong>#{@cached_label_priority}</strong>: #{issue.priority.name}"

  end

  def render_issue_subject_with_tree(issue)

    s = ''

      s << '<div>' + content_tag('p', link_to_issue(ancestor))

    end

    s

  end

  def render_descendants_tree(issue)

    s = '<form><table class="list issues">'

      s << content_tag('tr',

             content_tag('td', check_box_tag("ids[]", child.id, false, :id => nil), :class => 'checkbox') +

             content_tag('td', link_to_issue(child, :truncate => 60), :class => 'subject') +

    s << '</form></table>'

    s

  end

  def render_custom_fields_rows(issue)

    return if issue.custom_field_values.empty?

    ordered_values = []

    s << "</tr>\n"

    s

  end

  def sidebar_queries

    unless @sidebar_queries

      # User can see public queries and his own queries

      visible = ARCondition.new(["is_public = ? OR user_id = ?", true, (User.current.logged? ? User.current.id : 0)])

      # Project specific queries and global queries

      visible << (@project.nil? ? ["project_id IS NULL"] : ["project_id IS NULL OR project_id = ?", @project.id])

                                    :select => 'id, name, is_public',

                                    :order => "name ASC",

                                    :conditions => visible.conditions)

  def query_links(title, queries)

    # links to #index on issues/show

    url_params = controller_name == 'issues' ? {:controller => 'issues', :action => 'index', :project_id => @project} : params

    content_tag('h3', title) +

      queries.collect {|query|

          link_to(h(query.name), url_params.merge(:query_id => query))

        }.join('<br />')

  end

  def render_sidebar_queries

    out = ''

    queries = sidebar_queries.select {|q| !q.is_public?}

        label = l(:field_parent_issue)

        value = "##{detail.value}" unless detail.value.blank?

        old_value = "##{detail.old_value}" unless detail.old_value.blank?

      end

    when 'cf'

      custom_field = CustomField.find_by_id(detail.prop_key)

    label ||= detail.prop_key

    value ||= detail.value

    old_value ||= detail.old_value

    unless no_html

      label = content_tag('strong', label)

      old_value = content_tag("i", h(old_value)) if detail.old_value

        value = content_tag("i", h(value)) if value

      end

    end

    if detail.property == 'attr' && detail.prop_key == 'description'

      s = l(:text_journal_changed_no_detail, :label => label)

      unless no_html

          {:controller => 'journals', :action => 'diff', :id => detail.journal_id, :detail_id => detail.id},

          :title => l(:label_view_diff)

        s << " (#{ diff_link })"

      return record.name if record

    end

  end

  # Renders issue children recursively

  def render_api_issue_children(issue, api)

    return if issue.leaf?

      end

    end

  end

  def issues_to_csv(issues, project = nil)

    decimal_separator = l(:general_csv_decimal_separator)

    export = FCSV.generate(:col_sep => l(:general_csv_separator)) do |csv|

      # csv header fields

      headers = [ "#",

                  l(:field_project),

                  l(:field_tracker),

                  l(:field_priority),

      # csv lines

      issues.each do |issue|

        fields = [issue.id,

                  issue.project.name,

                  issue.priority.name,

                  issue.subject,

                  issue.assigned_to,

                  issue.done_ratio,

                  issue.estimated_hours.to_s.gsub('.', decimal_separator),

                  issue.parent_id,

                  format_time(issue.updated_on)

                  ]

        custom_fields.each {|f| fields << show_value(issue.custom_value_for(f)) }

#

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

    return '' unless version && version.is_a?(Version)

    link_to_if version.visible?, format_version_name(version), { :controller => 'versions', :action => 'show', :id => version }, options

  end

  def project_settings_tabs

    tabs = [{:name => 'info', :action => :edit_project, :partial => 'projects/edit', :label => :label_information_plural},

            {:name => 'modules', :action => :select_project_modules, :partial => 'projects/settings/modules', :label => :label_module_plural},

            {:name => 'boards', :action => :manage_boards, :partial => 'projects/settings/boards', :label => :label_board_plural},

            {:name => 'activities', :action => :manage_project_activities, :partial => 'projects/settings/activities', :label => :enumeration_activities}

            ]

  end

  def parent_project_select_tag(project)

    selected = project.parent

    # retrieve the requested parent project

    if parent_id

      selected = (parent_id.blank? ? nil : Project.find(parent_id))

    end

    options = ''

    options << "<option value=''></option>" if project.allowed_parents.include?(nil)

    options << project_tree_options_for_select(project.allowed_parents.compact, :selected => selected)

    content_tag('select', options, :name => 'project[parent_id]', :id => 'project_parent_id')

  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)

        else

          ancestors.pop

          s << "</li>"

            ancestors.pop

            s << "</ul></li>\n"

          end

    if selected && !versions.include?(selected)

      grouped[selected.project.name] << [selected.name, selected.id]

    end

    if grouped.keys.size > 1

      grouped_options_for_select(grouped, selected && selected.id)

    else

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

        # Give it a name, required to be valid

        @query = Query.new(:name => "_")

        @query.project = @project

          @query.filters = {}

        else

          @query.available_filters.keys.each do |field|

            @query.add_short_filter(field, params[field]) if params[field]

          end

        end

        @query.group_by = params[:group_by]

        session[:query] = {:project_id => @query.project_id, :filters => @query.filters, :group_by => @query.group_by, :column_names => @query.column_names}

      else

        @query = Query.find_by_id(session[:query][:id]) if session[:query][:id]

#

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

module ReportsHelper

  def aggregate(data, criteria)

    a = 0

    data.each { |row|

    } unless data.nil?

    a

  end

  def aggregate_link(data, criteria, *args)

    a = aggregate data, criteria

    a > 0 ? link_to(a, *args) : '-'

end

#

# 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 'iconv'

module RepositoriesHelper

  def format_revision(revision)

      when 'A'

        # Detects moved/copied files

        if !change.from_path.blank?

        end

        change

      when 'D'

      else

        change

      end

    tree = { }

    changes.each do |change|

      p = tree

      end

      p[:c] = change

    end

    render_changes_tree(tree[:s])

  end

  def render_changes_tree(tree)

    return '' if tree.nil?

    output = ''

    output << '<ul>'

    tree.keys.sort.each do |file|

  end

  def to_utf8(str)

    if str.respond_to?(:force_encoding)

      str.force_encoding('UTF-8')

    end

    @encodings ||= Setting.repositories_encodings.split(',').collect(&:strip)

    @encodings.each do |encoding|

      begin

        # do nothing here and try the next encoding

      end

    end

  end

  def repository_field_tags(form, repository)

    method = repository.class.name.demodulize.underscore + "_field_tags"

        scm_options << ["Repository::#{scm}".constantize.scm_name, scm]

      end

    end

               options_for_select(scm_options, repository.class.name.demodulize),

               :disabled => (repository && !repository.new_record?),

               :onchange => remote_function(

                  :url => {

                      :controller => 'repositories',

               :method => :get,

  end

  def with_leading_slash(path)

  end

  def darcs_field_tags(form, repository)

  end

  def mercurial_field_tags(form, repository)

                       :size => 60, :required => true,

  end

  def git_field_tags(form, repository)

                       :size => 60, :required => true,

  end

  def cvs_field_tags(form, repository)

  end

  def bazaar_field_tags(form, repository)

  end

  def filesystem_field_tags(form, repository)

                     :size => 60, :required => true,

                     :disabled => (repository && !repository.root_url.blank?))) +

    content_tag('p', form.select(

                        :path_encoding, [nil] + Setting::ENCODINGS,

  end

end

# Redmine - project management software

#

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

            {:name => 'repositories', :partial => 'settings/repositories', :label => :label_repository_plural}

            ]

  end

  def setting_select(setting, choices, options={})

    if blank_text = options.delete(:blank)

      choices = [[blank_text.is_a?(Symbol) ? l(blank_text) : blank_text, '']] + choices

    end

    setting_label(setting, options) +

  end

  def setting_multiselect(setting, choices, options={})

    setting_values = Setting.send(setting)

    setting_values = [] unless setting_values.is_a?(Array)

    setting_label(setting, options) +

      hidden_field_tag("settings[#{setting}][]", '') +

      choices.collect do |choice|

          :class => 'block'

      end.join

  end

  def setting_text_field(setting, options={})

    setting_label(setting, options) +

      text_field_tag("settings[#{setting}]", Setting.send(setting), options)

  end

  def setting_text_area(setting, options={})

    setting_label(setting, options) +

      text_area_tag("settings[#{setting}]", Setting.send(setting), options)

  end

  def setting_check_box(setting, options={})

    setting_label(setting, options) +

      hidden_field_tag("settings[#{setting}]", 0) +

  end

  def setting_label(setting, options={})

    label = options.delete(:label)

    label != false ? content_tag("label", l(label || "setting_#{setting}")) : ''

    caption = column.to_s.humanize unless caption

    sort_options = { :sort => @sort_criteria.add(column.to_s, order).to_param }

     # Add project_id to url_options

    url_options = url_options.merge(:project_id => params[:project_id]) if params.has_key?(:project_id)

  end

  # Returns a table header <th> tag with a sort link for the named column

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

module VersionsHelper

  def render_issue_status_by(version, criteria)

    h = Hash.new {|k,v| k[v] = [0, 0]}

    begin

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

module WatchersHelper

  end

    return '' unless user && user.logged? && object.respond_to?('watched_by?')

    watched = object.watched_by?(user)

    url = {:controller => 'watchers',

           :action => (watched ? 'unwatch' : 'watch'),

           :object_type => object.class.to_s.underscore,

    link_to_remote((watched ? l(:button_unwatch) : l(:button_watch)),

                   {:url => url},

                   :href => url_for(url),

  end

  # Returns a comma separated list of users watching the given object

  def watchers_list(object)

    remove_allowed = User.current.allowed_to?("delete_#{object.class.name.underscore}_watchers".to_sym, object.project)

module WikiHelper

  def wiki_page_options_for_select(pages, selected = nil, parent = nil, level = 0)

    s = ''

    end

    s

  end