jro_apps/redmine Commit - r1953:a3b9a5aa5fe3

Makes wiki text formatter pluggable....

Jean-Philippe Lang -

r1953:a3b9a5aa5fe3

parent child

Context file:

r1953:a3b9a5aa5fe3

Collapse all files

lib/redmine/wiki_formatting/textile/formatter.rb created 644 +183 0

@@ -0,0 +1,183
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2008 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require 'redcloth3'
	19	require 'coderay'
	20
	21	module Redmine
	22	module WikiFormatting
	23	module Textile
	24	class Formatter < RedCloth3
	25
	26	# auto_link rule after textile rules so that it doesn't break !image_url! tags
	27	RULES = [:textile, :block_markdown_rule, :inline_auto_link, :inline_auto_mailto, :inline_toc, :inline_macros]
	28
	29	def initialize(*args)
	30	super
	31	self.hard_breaks=true
	32	self.no_span_caps=true
	33	end
	34
	35	def to_html(*rules, &block)
	36	@toc = []
	37	@macros_runner = block
	38	super(*RULES).to_s
	39	end
	40
	41	private
	42
	43	# Patch for RedCloth. Fixed in RedCloth r128 but _why hasn't released it yet.
	44	# <a href="http://code.whytheluckystiff.net/redcloth/changeset/128">http://code.whytheluckystiff.net/redcloth/changeset/128</a>
	45	def hard_break( text )
	46	text.gsub!( /(.)\n(?!\n\|\Z\|>\| (>? [#*=]+(\s\|$)\|[{\|]))/, "\\1<br />\n" ) if hard_breaks
	47	end
	48
	49	# Patch to add code highlighting support to RedCloth
	50	def smooth_offtags( text )
	51	unless @pre_list.empty?
	52	## replace <pre> content
	53	text.gsub!(/<redpre#(\d+)>/) do
	54	content = @pre_list[$1.to_i]
	55	if content.match(/<code\s+class="(\w+)">\s?(.+)/m)
	56	content = "<code class=\"#{$1} CodeRay\">" +
	57	CodeRay.scan($2, $1.downcase).html(:escape => false, :line_numbers => :inline)
	58	end
	59	content
	60	end
	61	end
	62	end
	63
	64	# Patch to add 'table of content' support to RedCloth
	65	def textile_p_withtoc(tag, atts, cite, content)
	66	# removes wiki links from the item
	67	toc_item = content.gsub(/(\[\[\|\]\])/, '')
	68	# removes styles
	69	# eg. %{color:red}Triggers% => Triggers
	70	toc_item.gsub! %r[%\{[^\}]*\}([^%]+)%], '\\1'
	71
	72	# replaces non word caracters by dashes
	73	anchor = toc_item.gsub(%r{[^\w\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
	74
	75	unless anchor.blank?
	76	if tag =~ /^h(\d)$/
	77	@toc << [$1.to_i, anchor, toc_item]
	78	end
	79	atts << " id=\"#{anchor}\""
	80	content = content + "<a href=\"##{anchor}\" class=\"wiki-anchor\">¶</a>"
	81	end
	82	textile_p(tag, atts, cite, content)
	83	end
	84
	85	alias :textile_h1 :textile_p_withtoc
	86	alias :textile_h2 :textile_p_withtoc
	87	alias :textile_h3 :textile_p_withtoc
	88
	89	def inline_toc(text)
	90	text.gsub!(/<p>\{\{([<>]?)toc\}\}<\/p>/i) do
	91	div_class = 'toc'
	92	div_class << ' right' if $1 == '>'
	93	div_class << ' left' if $1 == '<'
	94	out = "<ul class=\"#{div_class}\">"
	95	@toc.each do \|heading\|
	96	level, anchor, toc_item = heading
	97	out << "<li class=\"heading#{level}\"><a href=\"##{anchor}\">#{toc_item}</a></li>\n"
	98	end
	99	out << '</ul>'
	100	out
	101	end
	102	end
	103
	104	MACROS_RE = /
	105	(!)? # escaping
	106	(
	107	\{\{ # opening tag
	108	([\w]+) # macro name
	109	($([^\}]*)$)? # optional arguments
	110	\}\} # closing tag
	111	)
	112	/x unless const_defined?(:MACROS_RE)
	113
	114	def inline_macros(text)
	115	text.gsub!(MACROS_RE) do
	116	esc, all, macro = $1, $2, $3.downcase
	117	args = ($5 \|\| '').split(',').each(&:strip)
	118	if esc.nil?
	119	begin
	120	@macros_runner.call(macro, args)
	121	rescue => e
	122	"<div class=\"flash error\">Error executing the <strong>#{macro}</strong> macro (#{e})</div>"
	123	end \|\| all
	124	else
	125	all
	126	end
	127	end
	128	end
	129
	130	AUTO_LINK_RE = %r{
	131	( # leading text
	132	<\w+.*?>\| # leading HTML tag, or
	133	[^=<>!:'"/]\| # leading punctuation, or
	134	^ # beginning of line
	135	)
	136	(
	137	(?:https?://)\| # protocol spec, or
	138	(?:ftp://)\|
	139	(?:www\.) # www.*
	140	)
	141	(
	142	(\S+?) # url
	143	(\/)? # slash
	144	)
	145	([^\w\=\/;]*?) # post
	146	(?=<\|\s\|$)
	147	}x unless const_defined?(:AUTO_LINK_RE)
	148
	149	# Turns all urls into clickable links (code from Rails).
	150	def inline_auto_link(text)
	151	text.gsub!(AUTO_LINK_RE) do
	152	all, leading, proto, url, post = $&, $1, $2, $3, $6
	153	if leading =~ /<a\s/i \|\| leading =~ /![<>=]?/
	154	# don't replace URL's that are already linked
	155	# and URL's prefixed with ! !> !< != (textile images)
	156	all
	157	else
	158	# Idea below : an URL with unbalanced parethesis and
	159	# ending by ')' is put into external parenthesis
	160	if ( url[-1]==?) and ((url.count("(") - url.count(")")) < 0 ) )
	161	url=url[0..-2] # discard closing parenth from url
	162	post = ")"+post # add closing parenth to post
	163	end
	164	%(#{leading}<a class="external" href="#{proto=="www."?"http://www.":proto}#{url}">#{proto + url}</a>#{post})
	165	end
	166	end
	167	end
	168
	169	# Turns all email addresses into clickable links (code from Rails).
	170	def inline_auto_mailto(text)
	171	text.gsub!(/([\w\.!#\$%\-+.]+@[A-Za-z0-9\-]+(\.[A-Za-z0-9\-]+)+)/) do
	172	mail = $1
	173	if text.match(/<a\b[^>]>(.)(#{Regexp.escape(mail)})(.*)<\/a>/)
	174	mail
	175	else
	176	%{<a href="mailto:#{mail}" class="email">#{mail}</a>}
	177	end
	178	end
	179	end
	180	end
	181	end
	182	end
	183	end

lib/redmine/wiki_formatting/textile/helper.rb created 644 +43 0

@@ -0,0 +1,43
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2008 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	module Redmine
	19	module WikiFormatting
	20	module Textile
	21	module Helper
	22	def wikitoolbar_for(field_id)
	23	help_link = l(:setting_text_formatting) + ': ' +
	24	link_to(l(:label_help), compute_public_path('wiki_syntax', 'help', 'html'),
	25	:onclick => "window.open(\"#{ compute_public_path('wiki_syntax', 'help', 'html') }\", \"\", \"resizable=yes, location=no, width=300, height=640, menubar=no, status=no, scrollbars=yes\"); return false;")
	26
	27	javascript_include_tag('jstoolbar/jstoolbar') +
	28	javascript_include_tag('jstoolbar/textile') +
	29	javascript_include_tag("jstoolbar/lang/jstoolbar-#{current_language}") +
	30	javascript_tag("var toolbar = new jsToolBar($('#{field_id}')); toolbar.setHelpLink('#{help_link}'); toolbar.draw();")
	31	end
	32
	33	def initial_page_content(page)
	34	"h1. #{@page.pretty_title}"
	35	end
	36
	37	def heads_for_wiki_formatter
	38	stylesheet_link_tag 'jstoolbar'
	39	end
	40	end
	41	end
	42	end
	43	end

public/javascripts/jstoolbar/textile.js created 644 +200 0

@@ -0,0 +1,200
	1	/* *** BEGIN LICENSE BLOCK ***
	2	* This file is part of DotClear.
	3	* Copyright (c) 2005 Nicolas Martin & Olivier Meunier and contributors. All
	4	* rights reserved.
	5	*
	6	* DotClear is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* DotClear is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with DotClear; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	* *** END LICENSE BLOCK ***
	21	*/
	22
	23	/* Modified by JP LANG for textile formatting */
	24
	25	// strong
	26	jsToolBar.prototype.elements.strong = {
	27	type: 'button',
	28	title: 'Strong',
	29	fn: {
	30	wiki: function() { this.singleTag('*') }
	31	}
	32	}
	33
	34	// em
	35	jsToolBar.prototype.elements.em = {
	36	type: 'button',
	37	title: 'Italic',
	38	fn: {
	39	wiki: function() { this.singleTag("_") }
	40	}
	41	}
	42
	43	// ins
	44	jsToolBar.prototype.elements.ins = {
	45	type: 'button',
	46	title: 'Underline',
	47	fn: {
	48	wiki: function() { this.singleTag('+') }
	49	}
	50	}
	51
	52	// del
	53	jsToolBar.prototype.elements.del = {
	54	type: 'button',
	55	title: 'Deleted',
	56	fn: {
	57	wiki: function() { this.singleTag('-') }
	58	}
	59	}
	60
	61	// code
	62	jsToolBar.prototype.elements.code = {
	63	type: 'button',
	64	title: 'Code',
	65	fn: {
	66	wiki: function() { this.singleTag('@') }
	67	}
	68	}
	69
	70	// spacer
	71	jsToolBar.prototype.elements.space1 = {type: 'space'}
	72
	73	// headings
	74	jsToolBar.prototype.elements.h1 = {
	75	type: 'button',
	76	title: 'Heading 1',
	77	fn: {
	78	wiki: function() {
	79	this.encloseLineSelection('h1. ', '',function(str) {
	80	str = str.replace(/^h\d+\.\s+/, '')
	81	return str;
	82	});
	83	}
	84	}
	85	}
	86	jsToolBar.prototype.elements.h2 = {
	87	type: 'button',
	88	title: 'Heading 2',
	89	fn: {
	90	wiki: function() {
	91	this.encloseLineSelection('h2. ', '',function(str) {
	92	str = str.replace(/^h\d+\.\s+/, '')
	93	return str;
	94	});
	95	}
	96	}
	97	}
	98	jsToolBar.prototype.elements.h3 = {
	99	type: 'button',
	100	title: 'Heading 3',
	101	fn: {
	102	wiki: function() {
	103	this.encloseLineSelection('h3. ', '',function(str) {
	104	str = str.replace(/^h\d+\.\s+/, '')
	105	return str;
	106	});
	107	}
	108	}
	109	}
	110
	111	// spacer
	112	jsToolBar.prototype.elements.space2 = {type: 'space'}
	113
	114	// ul
	115	jsToolBar.prototype.elements.ul = {
	116	type: 'button',
	117	title: 'Unordered list',
	118	fn: {
	119	wiki: function() {
	120	this.encloseLineSelection('','',function(str) {
	121	str = str.replace(/\r/g,'');
	122	return str.replace(/(\n\|^)[#-]?\s/g,"$1 ");
	123	});
	124	}
	125	}
	126	}
	127
	128	// ol
	129	jsToolBar.prototype.elements.ol = {
	130	type: 'button',
	131	title: 'Ordered list',
	132	fn: {
	133	wiki: function() {
	134	this.encloseLineSelection('','',function(str) {
	135	str = str.replace(/\r/g,'');
	136	return str.replace(/(\n\|^)[-]?\s/g,"$1# ");
	137	});
	138	}
	139	}
	140	}
	141
	142	// spacer
	143	jsToolBar.prototype.elements.space3 = {type: 'space'}
	144
	145	// bq
	146	jsToolBar.prototype.elements.bq = {
	147	type: 'button',
	148	title: 'Quote',
	149	fn: {
	150	wiki: function() {
	151	this.encloseLineSelection('','',function(str) {
	152	str = str.replace(/\r/g,'');
	153	return str.replace(/(\n\|^) ([^\n])/g,"$1> $2");
	154	});
	155	}
	156	}
	157	}
	158
	159	// unbq
	160	jsToolBar.prototype.elements.unbq = {
	161	type: 'button',
	162	title: 'Unquote',
	163	fn: {
	164	wiki: function() {
	165	this.encloseLineSelection('','',function(str) {
	166	str = str.replace(/\r/g,'');
	167	return str.replace(/(\n\|^) [>]? ([^\n]*)/g,"$1$2");
	168	});
	169	}
	170	}
	171	}
	172
	173	// pre
	174	jsToolBar.prototype.elements.pre = {
	175	type: 'button',
	176	title: 'Preformatted text',
	177	fn: {
	178	wiki: function() { this.encloseLineSelection('<pre>\n', '\n</pre>') }
	179	}
	180	}
	181
	182	// spacer
	183	jsToolBar.prototype.elements.space4 = {type: 'space'}
	184
	185	// wiki page
	186	jsToolBar.prototype.elements.link = {
	187	type: 'button',
	188	title: 'Wiki link',
	189	fn: {
	190	wiki: function() { this.encloseSelection("[[", "]]") }
	191	}
	192	}
	193	// image
	194	jsToolBar.prototype.elements.img = {
	195	type: 'button',
	196	title: 'Image',
	197	fn: {
	198	wiki: function() { this.encloseSelection("!", "!") }
	199	}
	200	}

app/controllers/wiki_controller.rb +8 -1

             # redMine - project management software
             # Copyright (C) 2006-2007  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 'diff'
             class WikiController < ApplicationController
               before_filter :find_wiki, :authorize
               verify :method => :post, :only => [:destroy, :destroy_attachment, :protect], :redirect_to => { :action => :index }
               helper :attachments
               include AttachmentsHelper
               # display a page (in editing mode if it doesn't exist)
               def index
                 page_title = params[:page]
                 @page = @wiki.find_or_new_page(page_title)
                 if @page.new_record?
                   if User.current.allowed_to?(:edit_wiki_pages, @project)
                     edit
                     render :action => 'edit'
                   else
                     render_404
                   end
                   return
                 end
                 if params[:version] && !User.current.allowed_to?(:view_wiki_edits, @project)
                   # Redirects user to the current version if he's not allowed to view previous versions
                   redirect_to :version => nil
                   return
                 end
                 @content = @page.content_for_version(params[:version])
                 if params[:export] == 'html'
                   export = render_to_string :action => 'export', :layout => false
                   send_data(export, :type => 'text/html', :filename => "#{@page.title}.html")
                   return
                 elsif params[:export] == 'txt'
                   send_data(@content.text, :type => 'text/plain', :filename => "#{@page.title}.txt")
                   return
                 end
             	@editable = editable?
                 render :action => 'show'
               end
               # edit an existing page or a new one
               def edit
                 @page = @wiki.find_or_new_page(params[:page])
                 return render_403 unless editable?
                 @page.content = WikiContent.new(:page => @page) if @page.new_record?
                 @content = @page.content_for_version(params[:version])
-                @content.text = "h1. #{@page.pretty_title}" if @content.text.blank?
+                @content.text = initial_page_content(@page) if @content.text.blank?
                 # don't keep previous comment
                 @content.comments = nil
                 if request.get?
                   # To prevent StaleObjectError exception when reverting to a previous version
                   @content.version = @page.content.version
                 else
                   if !@page.new_record? && @content.text == params[:content][:text]
                     # don't save if text wasn't changed
                     redirect_to :action => 'index', :id => @project, :page => @page.title
                     return
                   end
                   #@content.text = params[:content][:text]
                   #@content.comments = params[:content][:comments]
                   @content.attributes = params[:content]
                   @content.author = User.current
                   # if page is new @page.save will also save content, but not if page isn't a new record
                   if (@page.new_record? ? @page.save : @content.save)
                     redirect_to :action => 'index', :id => @project, :page => @page.title
                   end
                 end
               rescue ActiveRecord::StaleObjectError
                 # Optimistic locking exception
                 flash[:error] = l(:notice_locking_conflict)
               end
               # rename a page
               def rename
                 @page = @wiki.find_page(params[:page])
             	return render_403 unless editable?
                 @page.redirect_existing_links = true
                 # used to display the *original* title if some AR validation errors occur
                 @original_title = @page.pretty_title
                 if request.post? && @page.update_attributes(params[:wiki_page])
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'index', :id => @project, :page => @page.title
                 end
               end
               def protect
                 page = @wiki.find_page(params[:page])
                 page.update_attribute :protected, params[:protected]
                 redirect_to :action => 'index', :id => @project, :page => page.title
               end
               # show page history
               def history
                 @page = @wiki.find_page(params[:page])
                 @version_count = @page.content.versions.count
                 @version_pages = Paginator.new self, @version_count, per_page_option, params['p']
                 # don't load text
                 @versions = @page.content.versions.find :all,
                                                         :select => "id, author_id, comments, updated_on, version",
                                                         :order => 'version DESC',
                                                         :limit  =>  @version_pages.items_per_page + 1,
                                                         :offset =>  @version_pages.current.offset
                 render :layout => false if request.xhr?
               end
               def diff
                 @page = @wiki.find_page(params[:page])
                 @diff = @page.diff(params[:version], params[:version_from])
                 render_404 unless @diff
               end
               def annotate
                 @page = @wiki.find_page(params[:page])
                 @annotate = @page.annotate(params[:version])
               end
               # remove a wiki page and its history
               def destroy
                 @page = @wiki.find_page(params[:page])
             	return render_403 unless editable?
                 @page.destroy if @page
                 redirect_to :action => 'special', :id => @project, :page => 'Page_index'
               end
               # display special pages
               def special
                 page_title = params[:page].downcase
                 case page_title
                 # show pages index, sorted by title
                 when 'page_index', 'date_index'
                   # eager load information about last updates, without loading text
                   @pages = @wiki.pages.find :all, :select => "#{WikiPage.table_name}.*, #{WikiContent.table_name}.updated_on",
                                                   :joins => "LEFT JOIN #{WikiContent.table_name} ON #{WikiContent.table_name}.page_id = #{WikiPage.table_name}.id",
                                                   :order => 'title'
                   @pages_by_date = @pages.group_by {|p| p.updated_on.to_date}
                   @pages_by_parent_id = @pages.group_by(&:parent_id)
                 # export wiki to a single html file
                 when 'export'
                   @pages = @wiki.pages.find :all, :order => 'title'
                   export = render_to_string :action => 'export_multiple', :layout => false
                   send_data(export, :type => 'text/html', :filename => "wiki.html")
                   return
                 else
                   # requested special page doesn't exist, redirect to default page
                   redirect_to :action => 'index', :id => @project, :page => nil and return
                 end
                 render :action => "special_#{page_title}"
               end
               def preview
                 page = @wiki.find_page(params[:page])
                 # page is nil when previewing a new page
                 return render_403 unless page.nil? || editable?(page)
                 if page
                   @attachements = page.attachments
                   @previewed = page.content
                 end
                 @text = params[:content][:text]
                 render :partial => 'common/preview'
               end
               def add_attachment
                 @page = @wiki.find_page(params[:page])
                 return render_403 unless editable?
                 attach_files(@page, params[:attachments])
                 redirect_to :action => 'index', :page => @page.title
               end
               def destroy_attachment
                 @page = @wiki.find_page(params[:page])
                 return render_403 unless editable?
                 @page.attachments.find(params[:attachment_id]).destroy
                 redirect_to :action => 'index', :page => @page.title
               end
             private
               def find_wiki
                 @project = Project.find(params[:id])
                 @wiki = @project.wiki
                 render_404 unless @wiki
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               # Returns true if the current user is allowed to edit the page, otherwise false
               def editable?(page = @page)
                 page.editable_by?(User.current)
               end
+              # Returns the default content of a new wiki page
+              def initial_page_content(page)
+                helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
+                extend helper unless self.instance_of?(helper)
+                helper.instance_method(:initial_page_content).bind(self).call(page)
+              end
             end

app/helpers/application_helper.rb +13 -15

             # redMine - project management software
             # Copyright (C) 2006-2007  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 'coderay'
             require 'coderay/helpers/file_type'
+            require 'forwardable'
             module ApplicationHelper
               include Redmine::WikiFormatting::Macros::Definitions
+              extend Forwardable
+              def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
               def current_role
                 @current_role ||= User.current.role_for_project(@project)
               end
               # 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
               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
               # Display a link to remote if user is authorized
               def link_to_remote_if_authorized(name, options = {}, html_options = nil)
                 url = options[:url] || {}
                 link_to_remote(name, options, html_options) if authorize_for(url[:controller] || params[:controller], url[:action])
               end
               # Display a link to user's account page
               def link_to_user(user)
                 user ? link_to(user, :controller => 'account', :action => 'show', :id => user) : 'Anonymous'
               end
               def link_to_issue(issue, options={})
                 options[:class] ||= ''
                 options[:class] << ' issue'
                 options[:class] << ' closed' if issue.closed?
                 link_to "#{issue.tracker.name} ##{issue.id}", {:controller => "issues", :action => "show", :id => issue}, options
               end
               # 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'
                 link_to(h(text), {:controller => 'attachments', :action => action, :id => attachment, :filename => attachment.filename }, options)
               end
               def toggle_link(name, id, options={})
                 onclick = "Element.toggle('#{id}'); "
                 onclick << (options[:focus] ? "Form.Element.focus('#{options[:focus]}'); " : "this.blur(); ")
                 onclick << "return false;"
                 link_to(name, "#", :onclick => onclick)
               end
               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 prompt_to_remote(name, text, param, url, html_options = {})
                 html_options[:onclick] = "promptToRemote('#{text}', '#{param}', '#{url_for(url)}'); return false;"
                 link_to name, {}, html_options
               end
               def format_date(date)
                 return nil unless date
                 # "Setting.date_format.size < 2" is a temporary fix (content of date_format setting changed)
                 @date_format ||= (Setting.date_format.blank? || Setting.date_format.size < 2 ? l(:general_fmt_date) : Setting.date_format)
                 date.strftime(@date_format)
               end
               def format_time(time, include_date = true)
                 return nil unless time
                 time = time.to_time if time.is_a?(String)
                 zone = User.current.time_zone
                 local = zone ? time.in_time_zone(zone) : (time.utc? ? time.localtime : time)
                 @date_format ||= (Setting.date_format.blank? || Setting.date_format.size < 2 ? l(:general_fmt_date) : Setting.date_format)
                 @time_format ||= (Setting.time_format.blank? ? l(:general_fmt_time) : Setting.time_format)
                 include_date ? local.strftime("#{@date_format} #{@time_format}") : local.strftime(@time_format)
               end
               def distance_of_date_in_words(from_date, to_date = 0)
                 from_date = from_date.to_date if from_date.respond_to?(:to_date)
                 to_date = to_date.to_date if to_date.respond_to?(:to_date)
                 distance_in_days = (to_date - from_date).abs
                 lwr(:actionview_datehelper_time_in_words_day, distance_in_days)
               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
               # Truncates and returns the string as a single line
               def truncate_single_line(string, *args)
                 truncate(string, *args).gsub(%r{[\r\n]+}m, ' ')
               end
               def html_hours(text)
                 text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>')
               end
               def authoring(created, author)
                 time_tag = content_tag('acronym', distance_of_time_in_words(Time.now, created), :title => format_time(created))
                 author_tag = (author.is_a?(User) && !author.anonymous?) ? link_to(h(author), :controller => 'account', :action => 'show', :id => author) : h(author || 'Anonymous')
                 l(:label_added_time_by, author_tag, time_tag)
               end
               def l_or_humanize(s, options={})
                 k = "#{options[:prefix]}#{s}".to_sym
                 l_has_string?(k) ? l(k) : s.to_s.humanize
               end
               def day_name(day)
                 l(:general_day_names).split(',')[day-1]
               end
               def month_name(month)
                 l(:actionview_datehelper_select_month_names).split(',')[month-1]
               end
               def syntax_highlight(name, content)
                 type = CodeRay::FileType[name]
                 type ? CodeRay.scan(content, type).html : h(content)
               end
               def to_path_param(path)
                 path.to_s.split(%r{[/\\]}).select {|p| !p.blank?}
               end
               def pagination_links_full(paginator, count=nil, options={})
                 page_param = options.delete(:page_param) || :page
                 url_param = params.dup
                 # don't reuse params if filters are present
                 url_param.clear if url_param.has_key?(:set_filter)
                 html = ''
                 html << link_to_remote(('&#171; ' + l(:label_previous)),
                                         {:update => 'content',
                                          :url => url_param.merge(page_param => paginator.current.previous),
                                          :complete => 'window.scrollTo(0,0)'},
                                         {:href => url_for(:params => url_param.merge(page_param => paginator.current.previous))}) + ' ' if paginator.current.previous
                 html << (pagination_links_each(paginator, options) do |n|
                   link_to_remote(n.to_s,
                                   {:url => {:params => url_param.merge(page_param => n)},
                                    :update => 'content',
                                    :complete => 'window.scrollTo(0,0)'},
                                   {:href => url_for(:params => url_param.merge(page_param => n))})
                 end || '')
                 html << ' ' + link_to_remote((l(:label_next) + ' &#187;'),
                                              {:update => 'content',
                                               :url => url_param.merge(page_param => paginator.current.next),
                                               :complete => 'window.scrollTo(0,0)'},
                                              {:href => url_for(:params => url_param.merge(page_param => paginator.current.next))}) if paginator.current.next
                 unless count.nil?
                   html << [" (#{paginator.current.first_item}-#{paginator.current.last_item}/#{count})", per_page_links(paginator.items_per_page)].compact.join(' | ')
                 end
                 html
               end
               def per_page_links(selected=nil)
                 url_param = params.dup
                 url_param.clear if url_param.has_key?(:set_filter)
                 links = Setting.per_page_options_array.collect do |n|
                   n == selected ? n : link_to_remote(n, {:update => "content", :url => params.dup.merge(:per_page => n)},
                                                         {:href => url_for(url_param.merge(:per_page => n))})
                 end
                 links.size > 1 ? l(:label_display_per_page, links.join(', ')) : nil
               end
               def breadcrumb(*args)
                 elements = args.flatten
                 elements.any? ? content_tag('p', args.join(' &#187; ') + ' &#187; ', :class => 'breadcrumb') : nil
               end
               def html_title(*args)
                 if args.empty?
                   title = []
                   title << @project.name if @project
                   title += @html_title if @html_title
                   title << Setting.app_title
                   title.compact.join(' - ')
                 else
                   @html_title ||= []
                   @html_title += args
                 end
               end
               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
                   text = obj.send(args.shift).to_s
                 else
                   raise ArgumentError, 'invalid arguments to textilizable'
                 end
                 return '' if text.blank?
                 only_path = options.delete(:only_path) == false ? false : true
                 # when using an image link, try to use an attachment, if possible
                 attachments = options[:attachments] || (obj && obj.respond_to?(:attachments) ? obj.attachments : nil)
                 if attachments
                   attachments = attachments.sort_by(&:created_on).reverse
                   text = text.gsub(/!((\<|\=|\>)?(\([^\)]+\))?(\[[^\]]+\])?(\{[^\}]+\})?)(\S+\.(gif|jpg|jpeg|png))!/) do |m|
                     style = $1
                     filename = $6
                     rf = Regexp.new(Regexp.escape(filename),  Regexp::IGNORECASE)
                     # search for the picture in attachments
                     if found = attachments.detect { |att| att.filename =~ rf }
                       image_url = url_for :only_path => only_path, :controller => 'attachments', :action => 'download', :id => found
                       desc = found.description.to_s.gsub(/^([^\(\)]*).*$/, "\\1")
                       alt = desc.blank? ? nil : "(#{desc})"
                       "!#{style}#{image_url}#{alt}!"
                     else
                       "!#{style}#{filename}!"
                     end
                   end
                 end
-                text = (Setting.text_formatting == 'textile') ?
+                text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text) { |macro, args| exec_macro(macro, obj, args) }
-                  Redmine::WikiFormatting.to_html(text) { |macro, args| exec_macro(macro, obj, args) } :
-                  simple_format(auto_link(h(text)))
                 # different methods for formatting wiki links
                 case options[:wiki_links]
                 when :local
                   # used for local links to html files
                   format_wiki_link = Proc.new {|project, title, anchor| "#{title}.html" }
                 when :anchor
                   # used for single-file wiki export
                   format_wiki_link = Proc.new {|project, title, anchor| "##{title}" }
                 else
                   format_wiki_link = Proc.new {|project, title, anchor| url_for(:only_path => only_path, :controller => 'wiki', :action => 'index', :id => project, :page => title, :anchor => anchor) }
                 end
                 project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                 # Wiki links
                 #
                 # Examples:
                 #   [[mypage]]
                 #   [[mypage|mytext]]
                 # wiki links can refer other project wikis, using project name or identifier:
                 #   [[project:]] -> wiki starting page
                 #   [[project:|mytext]]
                 #   [[project:mypage]]
                 #   [[project:mypage|mytext]]
                 text = text.gsub(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
                   link_project = project
                   esc, all, page, title = $1, $2, $3, $5
                   if esc.nil?
                     if page =~ /^([^\:]+)\:(.*)$/
                       link_project = Project.find_by_name($1) || Project.find_by_identifier($1)
                       page = $2
                       title ||= $1 if page.blank?
                     end
                     if link_project && link_project.wiki
                       # extract anchor
                       anchor = nil
                       if page =~ /^(.+?)\#(.+)$/
                         page, anchor = $1, $2
                       end
                       # check if page exists
                       wiki_page = link_project.wiki.find_page(page)
                       link_to((title || page), format_wiki_link.call(link_project, Wiki.titleize(page), anchor),
                                                :class => ('wiki-page' + (wiki_page ? '' : ' new')))
                     else
                       # project or wiki doesn't exist
                       title || page
                     end
                   else
                     all
                   end
                 end
                 # Redmine links
                 #
                 # Examples:
                 #   Issues:
                 #     #52 -> Link to issue #52
                 #   Changesets:
                 #     r52 -> Link to revision 52
                 #     commit:a85130f -> Link to scmid starting with a85130f
                 #   Documents:
                 #     document#17 -> Link to document with id 17
                 #     document:Greetings -> Link to the document with title "Greetings"
                 #     document:"Some document" -> Link to the document with title "Some document"
                 #   Versions:
                 #     version#3 -> Link to version with id 3
                 #     version:1.0.0 -> Link to version named "1.0.0"
                 #     version:"1.0 beta 2" -> Link to version named "1.0 beta 2"
                 #   Attachments:
                 #     attachment:file.zip -> Link to the attachment of the current object named file.zip
                 #   Source files:
                 #     source:some/file -> Link to the file located at /some/file in the project's repository
                 #     source:some/file@52 -> Link to the file's revision 52
                 #     source:some/file#L120 -> Link to line 120 of the file
                 #     source:some/file@52#L120 -> Link to line 120 of the file's revision 52
                 #     export:some/file -> Force the download of the file
                 #  Forum messages:
                 #     message#1218 -> Link to message with id 1218
                 text = text.gsub(%r{([\s\(,\-\>]|^)(!)?(attachment|document|version|commit|source|export|message)?((#|r)(\d+)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]]\W)|\s|<|$)}) do |m|
                   leading, esc, prefix, sep, oid = $1, $2, $3, $5 || $7, $6 || $8
                   link = nil
                   if esc.nil?
                     if prefix.nil? && sep == 'r'
                       if project && (changeset = project.changesets.find_by_revision(oid))
                         link = link_to("r#{oid}", {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => oid},
                                                   :class => 'changeset',
                                                   :title => truncate_single_line(changeset.comments, 100))
                       end
                     elsif sep == '#'
                       oid = oid.to_i
                       case prefix
                       when nil
                         if issue = Issue.find_by_id(oid, :include => [:project, :status], :conditions => Project.visible_by(User.current))
                           link = link_to("##{oid}", {:only_path => only_path, :controller => 'issues', :action => 'show', :id => oid},
                                                     :class => (issue.closed? ? 'issue closed' : 'issue'),
                                                     :title => "#{truncate(issue.subject, 100)} (#{issue.status.name})")
                           link = content_tag('del', link) if issue.closed?
                         end
                       when 'document'
                         if document = Document.find_by_id(oid, :include => [:project], :conditions => Project.visible_by(User.current))
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if version = Version.find_by_id(oid, :include => [:project], :conditions => Project.visible_by(User.current))
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'message'
                         if message = Message.find_by_id(oid, :include => [:parent, {:board => :project}], :conditions => Project.visible_by(User.current))
                           link = link_to h(truncate(message.subject, 60)), {:only_path => only_path,
                                                                             :controller => 'messages',
                                                                             :action => 'show',
                                                                             :board_id => message.board,
                                                                             :id => message.root,
                                                                             :anchor => (message.parent ? "message-#{message.id}" : nil)},
                                                              :class => 'message'
                         end
                       end
                     elsif sep == ':'
                       # removes the double quotes if any
                       name = oid.gsub(%r{^"(.*)"$}, "\\1")
                       case prefix
                       when 'document'
                         if project && document = project.documents.find_by_title(name)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if project && version = project.versions.find_by_name(name)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'commit'
                         if project && (changeset = project.changesets.find(:first, :conditions => ["scmid LIKE ?", "#{name}%"]))
                           link = link_to h("#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => changeset.revision},
                                                        :class => 'changeset',
                                                        :title => truncate_single_line(changeset.comments, 100)
                         end
                       when 'source', 'export'
                         if project && project.repository
                           name =~ %r{^[/\\]*(.*?)(@([0-9a-f]+))?(#(L\d+))?$}
                           path, rev, anchor = $1, $3, $5
                           link = link_to h("#{prefix}:#{name}"), {:controller => 'repositories', :action => 'entry', :id => project,
                                                                   :path => to_path_param(path),
                                                                   :rev => rev,
                                                                   :anchor => anchor,
                                                                   :format => (prefix == 'export' ? 'raw' : nil)},
                                                                  :class => (prefix == 'export' ? 'source download' : 'source')
                         end
                       when 'attachment'
                         if attachments && attachment = attachments.detect {|a| a.filename == name }
                           link = link_to h(attachment.filename), {:only_path => only_path, :controller => 'attachments', :action => 'download', :id => attachment},
                                                                  :class => 'attachment'
                         end
                       end
                     end
                   end
                   leading + (link || "#{prefix}#{sep}#{oid}")
                 end
                 text
               end
               # 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
               end
               def error_messages_for(object_name, options = {})
                 options = options.symbolize_keys
                 object = instance_variable_get("@#{object_name}")
                 if object && !object.errors.empty?
                   # build full_messages here with controller current language
                   full_messages = []
                   object.errors.each do |attr, msg|
                     next if msg.nil?
                     msg = msg.first if msg.is_a? Array
                     if attr == "base"
                       full_messages << l(msg)
                     else
                       full_messages << "&#171; " + (l_has_string?("field_" + attr) ? l("field_" + attr) : object.class.human_attribute_name(attr)) + " &#187; " + l(msg) unless attr == "custom_values"
                     end
                   end
                   # retrieve custom values error messages
                   if object.errors[:custom_values]
                     object.custom_values.each do |v|
                       v.errors.each do |attr, msg|
                         next if msg.nil?
                         msg = msg.first if msg.is_a? Array
                         full_messages << "&#171; " + v.custom_field.name + " &#187; " + l(msg)
                       end
                     end
                   end
                   content_tag("div",
                     content_tag(
                       options[:header_tag] || "span", lwr(:gui_validation_error, full_messages.length) + ":"
                     ) +
                     content_tag("ul", full_messages.collect { |msg| content_tag("li", msg) }),
                     "id" => options[:id] || "errorExplanation", "class" => options[:class] || "errorExplanation"
                   )
                 else
                   ""
                 end
               end
               def lang_options_for_select(blank=true)
                 (blank ? [["(auto)", ""]] : []) +
                   GLoc.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_tabular_form_for(name, object, options, &proc)
                 options[:html] ||= {}
                 options[:html][:class] = 'tabular' unless options[:html].has_key?(:class)
                 form_for(name, object, options.merge({ :builder => TabularFormBuilder, :lang => current_language}), &proc)
               end
               def back_url_hidden_field_tag
                 back_url = params[:back_url] || request.env['HTTP_REFERER']
                 hidden_field_tag('back_url', back_url) unless back_url.blank?
               end
               def check_all_links(form_name)
                 link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
                 " | " +
                 link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
               end
               def progress_bar(pcts, options={})
                 pcts = [pcts, pcts] unless pcts.is_a?(Array)
                 pcts[1] = pcts[1] - pcts[0]
                 pcts << (100 - pcts[1] - pcts[0])
                 width = options[:width] || '100px;'
                 legend = options[:legend] || ''
                 content_tag('table',
                   content_tag('tr',
                     (pcts[0] > 0 ? content_tag('td', '', :width => "#{pcts[0].floor}%;", :class => 'closed') : '') +
                     (pcts[1] > 0 ? content_tag('td', '', :width => "#{pcts[1].floor}%;", :class => 'done') : '') +
                     (pcts[2] > 0 ? content_tag('td', '', :width => "#{pcts[2].floor}%;", :class => 'todo') : '')
                   ), :class => 'progress', :style => "width: #{width};") +
                   content_tag('p', legend, :class => 'pourcent')
               end
               def context_menu_link(name, url, options={})
                 options[:class] ||= ''
                 if options.delete(:selected)
                   options[:class] << ' icon-checked disabled'
                   options[:disabled] = true
                 end
                 if options.delete(:disabled)
                   options.delete(:method)
                   options.delete(:confirm)
                   options.delete(:onclick)
                   options[:class] << ' disabled'
                   url = '#'
                 end
                 link_to name, url, options
               end
               def calendar_for(field_id)
                 include_calendar_headers_tags
                 image_tag("calendar.png", {:id => "#{field_id}_trigger",:class => "calendar-trigger"}) +
                 javascript_tag("Calendar.setup({inputField : '#{field_id}', ifFormat : '%Y-%m-%d', button : '#{field_id}_trigger' });")
               end
               def include_calendar_headers_tags
                 unless @calendar_headers_tags_included
                   @calendar_headers_tags_included = true
                   content_for :header_tags do
                     javascript_include_tag('calendar/calendar') +
                     javascript_include_tag("calendar/lang/calendar-#{current_language}.js") +
                     javascript_include_tag('calendar/calendar-setup') +
                     stylesheet_link_tag('calendar')
                   end
                 end
               end
-              def wikitoolbar_for(field_id)
-                return '' unless Setting.text_formatting == 'textile'
-                help_link = l(:setting_text_formatting) + ': ' +
-                  link_to(l(:label_help), compute_public_path('wiki_syntax', 'help', 'html'),
-                                          :onclick => "window.open(\"#{ compute_public_path('wiki_syntax', 'help', 'html') }\", \"\", \"resizable=yes, location=no, width=300, height=640, menubar=no, status=no, scrollbars=yes\"); return false;")
-                javascript_include_tag('jstoolbar/jstoolbar') +
-                  javascript_include_tag("jstoolbar/lang/jstoolbar-#{current_language}") +
-                  javascript_tag("var toolbar = new jsToolBar($('#{field_id}')); toolbar.setHelpLink('#{help_link}'); toolbar.draw();")
-              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
+              private
+              def wiki_helper
+                helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
+                extend helper
+                return self
+              end
             end

app/views/layouts/base.rhtml +1 -1

             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
             <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
             <head>
             <title><%=h html_title %></title>
             <meta http-equiv="content-type" content="text/html; charset=utf-8" />
             <meta name="description" content="<%= Redmine::Info.app_name %>" />
             <meta name="keywords" content="issue,bug,tracker" />
             <%= stylesheet_link_tag 'application', :media => 'all' %>
             <%= javascript_include_tag :defaults %>
-            <%= stylesheet_link_tag 'jstoolbar' %>
+            <%= heads_for_wiki_formatter %>
             <!--[if IE]>
                 <style type="text/css">
                   * html body{ width: expression( document.documentElement.clientWidth < 900 ? '900px' : '100%' ); }
                   body {behavior: url(<%= stylesheet_path "csshover.htc" %>);}
                 </style>
             <![endif]-->
             <%= call_hook :view_layouts_base_html_head %>
             <!-- page specific tags -->
             <%= yield :header_tags -%>
             </head>
             <body>
             <div id="wrapper">
             <div id="top-menu">
                 <div id="account">
                     <%= render_menu :account_menu -%>
                 </div>
                 <%= content_tag('div', "#{l(:label_logged_as)} #{User.current.login}", :id => 'loggedas') if User.current.logged? %>
                 <%= render_menu :top_menu -%>
             </div>
             <div id="header">
                 <div id="quick-search">
                     <% form_tag({:controller => 'search', :action => 'index', :id => @project}, :method => :get ) do %>
                     <%= link_to l(:label_search), {:controller => 'search', :action => 'index', :id => @project}, :accesskey => accesskey(:search) %>:
                     <%= text_field_tag 'q', @question, :size => 20, :class => 'small', :accesskey => accesskey(:quick_search) %>
                     <% end %>
                     <%= render :partial => 'layouts/project_selector' if User.current.memberships.any? %>
                 </div>
                 <h1><%= h(@project && !@project.new_record? ? @project.name : Setting.app_title) %></h1>
                 <div id="main-menu">
                     <%= render_main_menu(@project) %>
                 </div>
             </div>
             <%= tag('div', {:id => 'main', :class => (has_content?(:sidebar) ? '' : 'nosidebar')}, true) %>
                 <div id="sidebar">
                     <%= yield :sidebar %>
                 </div>
                 <div id="content">
                         <%= content_tag('div', flash[:error], :class => 'flash error') if flash[:error] %>
                         <%= content_tag('div', flash[:notice], :class => 'flash notice') if flash[:notice] %>
                     <%= yield %>
                 </div>
             </div>
             <div id="ajax-indicator" style="display:none;"><span><%= l(:label_loading) %></span></div>
             <div id="footer">
                 Powered by <%= link_to Redmine::Info.app_name, Redmine::Info.url %> &copy; 2006-2008 Jean-Philippe Lang
             </div>
             </div>
             <%= call_hook :view_layouts_base_body_bottom %>
             </body>
             </html>

app/views/mailer/layout.text.html.rhtml +1 -1

             <html>
             <head>
             <style>
             body {
               font-family: Verdana, sans-serif;
               font-size: 0.8em;
               color:#484848;
             }
             h1 {
               font-family: "Trebuchet MS", Verdana, sans-serif;
               font-size: 1.2em;
               margin: 0px;
             }
             a, a:link, a:visited {
               color: #2A5685;
             }
             a:hover, a:active {
               color: #c61a1a;
             }
             hr {
               width: 100%;
               height: 1px;
               background: #ccc;
               border: 0;
             }
             .footer {
               font-size: 0.8em;
               font-style: italic;
             }
             </style>
             </head>
             <body>
             <%= yield %>
             <hr />
-            <span class="footer"><%= Redmine::WikiFormatting.to_html(Setting.emails_footer) %></span>
+            <span class="footer"><%= Redmine::WikiFormatting.to_html(Setting.text_formatting, Setting.emails_footer) %></span>
             </body>
             </html>

app/views/settings/_general.rhtml +1 -1

             <% form_tag({:action => 'edit'}) do %>
             <div class="box tabular settings">
             <p><label><%= l(:setting_app_title) %></label>
             <%= text_field_tag 'settings[app_title]', Setting.app_title, :size => 30 %></p>
             <p><label><%= l(:setting_welcome_text) %></label>
             <%= text_area_tag 'settings[welcome_text]', Setting.welcome_text, :cols => 60, :rows => 5, :class => 'wiki-edit' %></p>
             <%= wikitoolbar_for 'settings[welcome_text]' %>
             <p><label><%= l(:label_theme) %></label>
             <%= select_tag 'settings[ui_theme]', options_for_select( ([[l(:label_default), '']] + Redmine::Themes.themes.collect {|t| [t.name, t.id]}), Setting.ui_theme) %></p>
             <p><label><%= l(:setting_default_language) %></label>
             <%= select_tag 'settings[default_language]', options_for_select( lang_options_for_select(false), Setting.default_language) %></p>
             <p><label><%= l(:setting_date_format) %></label>
             <%= select_tag 'settings[date_format]', options_for_select( [[l(:label_language_based), '']] + Setting::DATE_FORMATS.collect {|f| [Date.today.strftime(f), f]}, Setting.date_format) %></p>
             <p><label><%= l(:setting_time_format) %></label>
             <%= select_tag 'settings[time_format]', options_for_select( [[l(:label_language_based), '']] + Setting::TIME_FORMATS.collect {|f| [Time.now.strftime(f), f]}, Setting.time_format) %></p>
             <p><label><%= l(:setting_user_format) %></label>
             <%= select_tag 'settings[user_format]', options_for_select( @options[:user_format], Setting.user_format.to_s ) %></p>
             <p><label><%= l(:setting_attachment_max_size) %></label>
             <%= text_field_tag 'settings[attachment_max_size]', Setting.attachment_max_size, :size => 6 %> KB</p>
             <p><label><%= l(:setting_per_page_options) %></label>
             <%= text_field_tag 'settings[per_page_options]', Setting.per_page_options_array.join(', '), :size => 20 %><br /><em><%= l(:text_comma_separated) %></em></p>
             <p><label><%= l(:setting_activity_days_default) %></label>
             <%= text_field_tag 'settings[activity_days_default]', Setting.activity_days_default, :size => 6 %> <%= l(:label_day_plural) %></p>
             <p><label><%= l(:setting_host_name) %></label>
             <%= text_field_tag 'settings[host_name]', Setting.host_name, :size => 60 %></p>
             <p><label><%= l(:setting_protocol) %></label>
             <%= select_tag 'settings[protocol]', options_for_select(['http', 'https'], Setting.protocol) %></p>
             <p><label><%= l(:setting_text_formatting) %></label>
-            <%= select_tag 'settings[text_formatting]', options_for_select([[l(:label_none), "0"], ["textile", "textile"]], Setting.text_formatting) %></p>
+            <%= select_tag 'settings[text_formatting]', options_for_select([[l(:label_none), "0"], *Redmine::WikiFormatting.format_names.collect{|name| [name, name]} ], Setting.text_formatting.to_sym) %></p>
             <p><label><%= l(:setting_wiki_compression) %></label>
             <%= select_tag 'settings[wiki_compression]', options_for_select( [[l(:label_none), 0], ["gzip", "gzip"]], Setting.wiki_compression) %></p>
             <p><label><%= l(:setting_feeds_limit) %></label>
             <%= text_field_tag 'settings[feeds_limit]', Setting.feeds_limit, :size => 6 %></p>
             </div>
             <%= submit_tag l(:button_save) %>
             <% end %>

lib/redmine.rb +5 0

             require 'redmine/access_control'
             require 'redmine/menu_manager'
             require 'redmine/activity'
             require 'redmine/mime_type'
             require 'redmine/core_ext'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/plugin'
+            require 'redmine/wiki_formatting'
             begin
               require_library_or_gem 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             REDMINE_SUPPORTED_SCM = %w( Subversion Darcs Mercurial Cvs Bazaar Git Filesystem )
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show, :activity]}, :public => true
               map.permission :search_project, {:search => :index}, :public => true
               map.permission :edit_project, {:projects => [:settings, :edit]}, :require => :member
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:new, :edit, :destroy]}, :require => :member
               map.permission :manage_versions, {:projects => [:settings, :add_version], :versions => [:edit, :destroy]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => [:settings, :add_issue_category], :issue_categories => [:edit, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:projects => [:changelog, :roadmap],
                                               :issues => [:index, :changes, :show, :context_menu],
                                               :versions => [:show, :status_by],
                                               :queries => :index,
                                               :reports => :issue_report}, :public => true
                 map.permission :add_issues, {:issues => :new}
                 map.permission :edit_issues, {:issues => [:edit, :reply, :bulk_edit, :destroy_attachment]}
                 map.permission :manage_issue_relations, {:issue_relations => [:new, :destroy]}
                 map.permission :add_issue_notes, {:issues => [:edit, :reply]}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :move_issues, {:issues => :move}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :edit, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :edit, :destroy]}, :require => :loggedin
                 # Gantt & calendar
                 map.permission :view_gantt, :issues => :gantt
                 map.permission :view_calendar, :issues => :calendar
                 # Watchers
                 map.permission :view_issue_watchers, {}
                 map.permission :add_issue_watchers, {:watchers => :new}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => :edit}, :require => :loggedin
                 map.permission :view_time_entries, :timelog => [:details, :report]
                 map.permission :edit_time_entries, {:timelog => [:edit, :destroy]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :destroy]}, :require => :loggedin
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :edit, :destroy, :destroy_comment]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true
                 map.permission :comment_news, {:news => :add_comment}
               end
               map.project_module :documents do |map|
                 map.permission :manage_documents, {:documents => [:new, :edit, :destroy, :add_attachment, :destroy_attachment]}, :require => :loggedin
                 map.permission :view_documents, :documents => [:index, :show, :download]
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:projects => :add_file, :versions => :destroy_file}, :require => :loggedin
                 map.permission :view_files, :projects => :list_files, :versions => :download
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => :destroy}, :require => :member
                 map.permission :view_wiki_pages, :wiki => [:index, :special]
                 map.permission :view_wiki_edits, :wiki => [:history, :diff, :annotate]
                 map.permission :edit_wiki_pages, :wiki => [:edit, :preview, :add_attachment]
                 map.permission :delete_wiki_pages_attachments, :wiki => :destroy_attachment
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:edit, :destroy]}, :require => :member
                 map.permission :browse_repository, :repositories => [:show, :browse, :entry, :annotate, :changes, :diff, :stats, :graph]
                 map.permission :view_changesets, :repositories => [:show, :revisions, :revision]
                 map.permission :commit_access, {}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :edit, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote]}
                 map.permission :edit_messages, {:messages => :edit}, :require => :member
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path, :html => { :class => 'home' }
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :html => { :class => 'mypage' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural, :html => { :class => 'projects' }
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :html => { :class => 'admin' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :html => { :class => 'help' }, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :html => { :class => 'login' }, :if => Proc.new { !User.current.logged? }
               menu.push :register, { :controller => 'account', :action => 'register' }, :html => { :class => 'register' }, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :html => { :class => 'myaccount' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :html => { :class => 'logout' }, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'projects', :action => 'activity' }
               menu.push :roadmap, { :controller => 'projects', :action => 'roadmap' },
                           :if => Proc.new { |p| p.versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new' }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'index', :page => nil },
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'projects', :action => 'list_files' }, :caption => :label_attachment_plural
               menu.push :repository, { :controller => 'repositories', :action => 'show' },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
             end
             Redmine::Activity.map do |activity|
               activity.register :issues, :class_name => %w(Issue Journal)
               activity.register :changesets
               activity.register :news
               activity.register :documents, :class_name => %w(Document Attachment)
               activity.register :files, :class_name => 'Attachment'
               activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
             end
+            Redmine::WikiFormatting.map do |format|
+              format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
+            end

lib/redmine/plugin.rb +10 0

             # redMine - project management software
             # Copyright (C) 2006-2007  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.
             module Redmine #:nodoc:
               # Base class for Redmine plugins.
               # Plugins are registered using the <tt>register</tt> class method that acts as the public constructor.
               #
               #   Redmine::Plugin.register :example do
               #     name 'Example plugin'
               #     author 'John Smith'
               #     description 'This is an example plugin for Redmine'
               #     version '0.0.1'
               #     settings :default => {'foo'=>'bar'}, :partial => 'settings/settings'
               #   end
               #
               # === Plugin attributes
               #
               # +settings+ is an optional attribute that let the plugin be configurable.
               # It must be a hash with the following keys:
               # * <tt>:default</tt>: default value for the plugin settings
               # * <tt>:partial</tt>: path of the configuration partial view, relative to the plugin <tt>app/views</tt> directory
               # Example:
               #   settings :default => {'foo'=>'bar'}, :partial => 'settings/settings'
               # In this example, the settings partial will be found here in the plugin directory: <tt>app/views/settings/_settings.rhtml</tt>.
               #
               # When rendered, the plugin settings value is available as the local variable +settings+
               class Plugin
                 @registered_plugins = {}
                 class << self
                   attr_reader :registered_plugins
                   private :new
                   def def_field(*names)
                     class_eval do
                       names.each do |name|
                         define_method(name) do |*args|
                           args.empty? ? instance_variable_get("@#{name}") : instance_variable_set("@#{name}", *args)
                         end
                       end
                     end
                   end
                 end
                 def_field :name, :description, :author, :version, :settings
                 # Plugin constructor
                 def self.register(name, &block)
                   p = new
                   p.instance_eval(&block)
                   Plugin.registered_plugins[name] = p
                 end
                 # Adds an item to the given +menu+.
                 # The +id+ parameter (equals to the project id) is automatically added to the url.
                 #   menu :project_menu, :plugin_example, { :controller => 'example', :action => 'say_hello' }, :caption => 'Sample'
                 #
                 # +name+ parameter can be: :top_menu, :account_menu, :application_menu or :project_menu
                 #
                 def menu(menu, item, url, options={})
                   Redmine::MenuManager.map(menu).push(item, url, options)
                 end
                 alias :add_menu_item :menu
                 # Removes +item+ from the given +menu+.
                 def delete_menu_item(menu, item)
                   Redmine::MenuManager.map(menu).delete(item)
                 end
                 # Defines a permission called +name+ for the given +actions+.
                 #
                 # The +actions+ argument is a hash with controllers as keys and actions as values (a single value or an array):
                 #   permission :destroy_contacts, { :contacts => :destroy }
                 #   permission :view_contacts, { :contacts => [:index, :show] }
                 #
                 # The +options+ argument can be used to make the permission public (implicitly given to any user)
                 # or to restrict users the permission can be given to.
                 #
                 # Examples
                 #   # A permission that is implicitly given to any user
                 #   # This permission won't appear on the Roles & Permissions setup screen
                 #   permission :say_hello, { :example => :say_hello }, :public => true
                 #
                 #   # A permission that can be given to any user
                 #   permission :say_hello, { :example => :say_hello }
                 #
                 #   # A permission that can be given to registered users only
                 #   permission :say_hello, { :example => :say_hello }, :require => loggedin
                 #
                 #   # A permission that can be given to project members only
                 #   permission :say_hello, { :example => :say_hello }, :require => member
                 def permission(name, actions, options = {})
                   if @project_module
                     Redmine::AccessControl.map {|map| map.project_module(@project_module) {|map|map.permission(name, actions, options)}}
                   else
                     Redmine::AccessControl.map {|map| map.permission(name, actions, options)}
                   end
                 end
                 # Defines a project module, that can be enabled/disabled for each project.
                 # Permissions defined inside +block+ will be bind to the module.
                 #
                 #   project_module :things do
                 #     permission :view_contacts, { :contacts => [:list, :show] }, :public => true
                 #     permission :destroy_contacts, { :contacts => :destroy }
                 #   end
                 def project_module(name, &block)
                   @project_module = name
                   self.instance_eval(&block)
                   @project_module = nil
                 end
                 # Registers an activity provider.
                 #
                 # Options:
                 # * <tt>:class_name</tt> - one or more model(s) that provide these events (inferred from event_type by default)
                 # * <tt>:default</tt> - setting this option to false will make the events not displayed by default
                 #
                 # A model can provide several activity event types.
                 #
                 # Examples:
                 #   register :news
                 #   register :scrums, :class_name => 'Meeting'
                 #   register :issues, :class_name => ['Issue', 'Journal']
                 #
                 # Retrieving events:
                 # Associated model(s) must implement the find_events class method.
                 # ActiveRecord models can use acts_as_activity_provider as a way to implement this class method.
                 #
                 # The following call should return all the scrum events visible by current user that occured in the 5 last days:
                 #   Meeting.find_events('scrums', User.current, 5.days.ago, Date.today)
                 #   Meeting.find_events('scrums', User.current, 5.days.ago, Date.today, :project => foo) # events for project foo only
                 #
                 # Note that :view_scrums permission is required to view these events in the activity view.
                 def activity_provider(*args)
                   Redmine::Activity.register(*args)
                 end
+                # Registers a wiki formatter.
+                #
+                # Parameters:
+                # * +name+ - human-readable name
+                # * +formatter+ - formatter class, which should have an instance method +to_html+
+                # * +helper+ - helper module, which will be included by wiki pages
+                def wiki_format_provider(name, formatter, helper)
+                  Redmine::WikiFormatting.register(name, formatter, helper)
+                end
                 # Returns +true+ if the plugin can be configured.
                 def configurable?
                   settings && settings.is_a?(Hash) && !settings[:partial].blank?
                 end
               end
             end

lib/redmine/wiki_formatting.rb +41 -152

@@ -1,190 +1,79
1	# ~~redM~~ine - project management software	1	# Redmine - project management software
2	# Copyright (C) 2006-2007 Jean-Philippe Lang	2	# Copyright (C) 2006-2008 Jean-Philippe Lang
3	#	3	#
4	# This program is free software; you can redistribute it and/or	4	# This program is free software; you can redistribute it and/or
5	# modify it under the terms of the GNU General Public License	5	# modify it under the terms of the GNU General Public License
6	# as published by the Free Software Foundation; either version 2	6	# as published by the Free Software Foundation; either version 2
7	# of the License, or (at your option) any later version.	7	# of the License, or (at your option) any later version.
8	#	8	#
9	# This program is distributed in the hope that it will be useful,	9	# This program is distributed in the hope that it will be useful,
10	# but WITHOUT ANY WARRANTY; without even the implied warranty of	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	# GNU General Public License for more details.	12	# GNU General Public License for more details.
13	#	13	#
14	# You should have received a copy of the GNU General Public License	14	# You should have received a copy of the GNU General Public License
15	# along with this program; if not, write to the Free Software	15	# along with this program; if not, write to the Free Software
16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17		17
18	require 'redcloth3'
19	require 'coderay'
20
21	module Redmine	18	module Redmine
22	module WikiFormatting	19	module WikiFormatting
23		20	@@formatters = {}
24	private	21
25		22	class << self
26	class TextileFormatter < RedCloth3	23	def map
27		24	yield self
28	# auto_link rule after textile rules so that it doesn't break !image_url! tags	25	end
29	RULES = [:textile, :block_markdown_rule, :inline_auto_link, :inline_auto_mailto, :inline_toc, :inline_macros]
30		26
31	def initialize(*args)	27	def register(name, formatter, helper)
32	super	28	raise ArgumentError, "format name '#{name}' is already taken" if @@formatters[name]
33	self.hard_breaks=true	29	@@formatters[name.to_sym] = {:formatter => formatter, :helper => helper}
34	self.no_span_caps=true
35	end	30	end
36		31
37	def to_html(*rules, &block)	32	def formatter_for(name)
38	@toc = []	33	entry = @@formatters[name.to_sym]
39	@macros_runner = block	34	(entry && entry[:formatter]) \|\| Redmine::WikiFormatting::NullFormatter::Formatter
40	super(*RULES).to_s
41	end	35	end
42		36
43	private	37	def helper_for(name)
44		38	entry = @@formatters[name.to_sym]
45	# Patch for RedCloth. Fixed in RedCloth r128 but _why hasn't released it yet.	39	(entry && entry[:helper]) \|\| Redmine::WikiFormatting::NullFormatter::Helper
46	# <a href="http://code.whytheluckystiff.net/redcloth/changeset/128">http://code.whytheluckystiff.net/redcloth/changeset/128</a>
47	def hard_break( text )
48	text.gsub!( /(.)\n(?!\n\|\Z\|>\| (>? [#*=]+(\s\|$)\|[{\|]))/, "\\1<br />\n" ) if hard_breaks
49	end	40	end
50		41
51	# Patch to add code highlighting support to RedCloth	42	def format_names
52	def smooth_offtags( text )	43	@@formatters.keys.map
53	unless @pre_list.empty?
54	## replace <pre> content
55	text.gsub!(/<redpre#(\d+)>/) do
56	content = @pre_list[$1.to_i]
57	if content.match(/<code\s+class="(\w+)">\s?(.+)/m)
58	content = "<code class=\"#{$1} CodeRay\">" +
59	CodeRay.scan($2, $1.downcase).html(:escape => false, :line_numbers => :inline)
60	end
61	content
62	end
63	end
64	end	44	end
65		45
66	# Patch to add 'table of content' support to RedCloth	46	def to_html(format, text, options = {}, &block)
67	def textile_p_withtoc(tag, atts, cite, content)	47	formatter_for(format).new(text).to_html(&block)
68	# removes wiki links from the item	48	end
69	toc_item = content.gsub(/(\[\[\|\]\])/, '')	49	end
70	# removes styles	50
71	# eg. %{color:red}Triggers% => Triggers	51	# Default formatter module
72	toc_item.gsub! %r[%\{[^\}]*\}([^%]+)%], '\\1'	52	module NullFormatter
		53	class Formatter
		54	include ActionView::Helpers::TagHelper
		55	include ActionView::Helpers::TextHelper
73		56
74	# replaces non word caracters by dashes	57	def initialize(text)
75	anchor = toc_item.gsub(%r{[^\w\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')	58	@text = text
76
77	unless anchor.blank?
78	if tag =~ /^h(\d)$/
79	@toc << [$1.to_i, anchor, toc_item]
80	end
81	atts << " id=\"#{anchor}\""
82	content = content + "<a href=\"##{anchor}\" class=\"wiki-anchor\">¶</a>"
83	end	59	end
84	textile_p(tag, atts, cite, content)	60
85	end	61	def to_html(*args)
86		62	simple_format(auto_link(CGI::escapeHTML(@text)))
87	alias :textile_h1 :textile_p_withtoc
88	alias :textile_h2 :textile_p_withtoc
89	alias :textile_h3 :textile_p_withtoc
90
91	def inline_toc(text)
92	text.gsub!(/<p>\{\{([<>]?)toc\}\}<\/p>/i) do
93	div_class = 'toc'
94	div_class << ' right' if $1 == '>'
95	div_class << ' left' if $1 == '<'
96	out = "<ul class=\"#{div_class}\">"
97	@toc.each do \|heading\|
98	level, anchor, toc_item = heading
99	out << "<li class=\"heading#{level}\"><a href=\"##{anchor}\">#{toc_item}</a></li>\n"
100	end
101	out << '</ul>'
102	out
103	end	63	end
104	end	64	end
105		65
106	MACROS_RE = /	66	module Helper
107	(!)? # escaping	67	def wikitoolbar_for(field_id)
108	(
109	\{\{ # opening tag
110	([\w]+) # macro name
111	($([^\}]*)$)? # optional arguments
112	\}\} # closing tag
113	)
114	/x unless const_defined?(:MACROS_RE)
115
116	def inline_macros(text)
117	text.gsub!(MACROS_RE) do
118	esc, all, macro = $1, $2, $3.downcase
119	args = ($5 \|\| '').split(',').each(&:strip)
120	if esc.nil?
121	begin
122	@macros_runner.call(macro, args)
123	rescue => e
124	"<div class=\"flash error\">Error executing the <strong>#{macro}</strong> macro (#{e})</div>"
125	end \|\| all
126	else
127	all
128	end
129	end	68	end
130	end
131		69
132	AUTO_LINK_RE = %r{	70	def heads_for_wiki_formatter
133	( # leading text
134	<\w+.*?>\| # leading HTML tag, or
135	[^=<>!:'"/]\| # leading punctuation, or
136	^ # beginning of line
137	)
138	(
139	(?:https?://)\| # protocol spec, or
140	(?:ftp://)\|
141	(?:www\.) # www.*
142	)
143	(
144	(\S+?) # url
145	(\/)? # slash
146	)
147	([^\w\=\/;]*?) # post
148	(?=<\|\s\|$)
149	}x unless const_defined?(:AUTO_LINK_RE)
150
151	# Turns all urls into clickable links (code from Rails).
152	def inline_auto_link(text)
153	text.gsub!(AUTO_LINK_RE) do
154	all, leading, proto, url, post = $&, $1, $2, $3, $6
155	if leading =~ /<a\s/i \|\| leading =~ /![<>=]?/
156	# don't replace URL's that are already linked
157	# and URL's prefixed with ! !> !< != (textile images)
158	all
159	else
160	# Idea below : an URL with unbalanced parethesis and
161	# ending by ')' is put into external parenthesis
162	if ( url[-1]==?) and ((url.count("(") - url.count(")")) < 0 ) )
163	url=url[0..-2] # discard closing parenth from url
164	post = ")"+post # add closing parenth to post
165	end
166	%(#{leading}<a class="external" href="#{proto=="www."?"http://www.":proto}#{url}">#{proto + url}</a>#{post})
167	end
168	end	71	end
169	~~end~~	72
170		73	def initial_page_content(page)
171	# Turns all email addresses into clickable links (code from Rails).	74	page.pretty_title.to_s
172	def inline_auto_mailto(text)
173	text.gsub!(/([\w\.!#\$%\-+.]+@[A-Za-z0-9\-]+(\.[A-Za-z0-9\-]+)+)/) do
174	mail = $1
175	if text.match(/<a\b[^>]>(.)(#{Regexp.escape(mail)})(.*)<\/a>/)
176	mail
177	else
178	%{<a href="mailto:#{mail}" class="email">#{mail}</a>}
179	end
180	end	75	end
181	end	76	end
182	end	77	end
183
184	public
185
186	def self.to_html(text, options = {}, &block)
187	TextileFormatter.new(text).to_html(&block)
188	end
189	end	78	end
190	end	79	end

public/javascripts/jstoolbar/jstoolbar.js 0 -179

             /* ***** BEGIN LICENSE BLOCK *****
              * This file is part of DotClear.
              * Copyright (c) 2005 Nicolas Martin & Olivier Meunier and contributors. All
              * rights reserved.
              *
              * DotClear 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.
              *
              * DotClear 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 DotClear; if not, write to the Free Software
              * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              * ***** END LICENSE BLOCK *****
             */
             /* Modified by JP LANG for textile formatting */
             function jsToolBar(textarea) {
             	if (!document.createElement) { return; }
             	if (!textarea) { return; }
             	if ((typeof(document["selection"]) == "undefined")
             	&& (typeof(textarea["setSelectionRange"]) == "undefined")) {
             		return;
             	}
             	this.textarea = textarea;
             	this.editor = document.createElement('div');
             	this.editor.className = 'jstEditor';
             	this.textarea.parentNode.insertBefore(this.editor,this.textarea);
             	this.editor.appendChild(this.textarea);
             	this.toolbar = document.createElement("div");
             	this.toolbar.className = 'jstElements';
             	this.editor.parentNode.insertBefore(this.toolbar,this.editor);
             	// Dragable resizing (only for gecko)
             	if (this.editor.addEventListener)
             	{
             		this.handle = document.createElement('div');
             		this.handle.className = 'jstHandle';
             		var dragStart = this.resizeDragStart;
             		var This = this;
             		this.handle.addEventListener('mousedown',function(event) { dragStart.call(This,event); },false);
             		// fix memory leak in Firefox (bug #241518)
             		window.addEventListener('unload',function() {
             				var del = This.handle.parentNode.removeChild(This.handle);
             				delete(This.handle);
             		},false);
             		this.editor.parentNode.insertBefore(this.handle,this.editor.nextSibling);
             	}
             	this.context = null;
             	this.toolNodes = {}; // lorsque la toolbar est dessinée , cet objet est garni
             					// de raccourcis vers les éléments DOM correspondants aux outils.
             }
             function jsButton(title, fn, scope, className) {
                 if(typeof jsToolBar.strings == 'undefined') {
                   this.title = title || null;
                 } else {
                   this.title = jsToolBar.strings[title] || title || null;
                 }
             	this.fn = fn || function(){};
             	this.scope = scope || null;
             	this.className = className || null;
             }
             jsButton.prototype.draw = function() {
             	if (!this.scope) return null;
             	var button = document.createElement('button');
             	button.setAttribute('type','button');
             	button.tabIndex = 200;
             	if (this.className) button.className = this.className;
             	button.title = this.title;
             	var span = document.createElement('span');
             	span.appendChild(document.createTextNode(this.title));
             	button.appendChild(span);
             	if (this.icon != undefined) {
             		button.style.backgroundImage = 'url('+this.icon+')';
             	}
             	if (typeof(this.fn) == 'function') {
             		var This = this;
             		button.onclick = function() { try { This.fn.apply(This.scope, arguments) } catch (e) {} return false; };
             	}
             	return button;
             }
             function jsSpace(id) {
             	this.id = id || null;
             	this.width = null;
             }
             jsSpace.prototype.draw = function() {
             	var span = document.createElement('span');
             	if (this.id) span.id = this.id;
             	span.appendChild(document.createTextNode(String.fromCharCode(160)));
             	span.className = 'jstSpacer';
             	if (this.width) span.style.marginRight = this.width+'px';
             	return span;
             }
             function jsCombo(title, options, scope, fn, className) {
             	this.title = title || null;
             	this.options = options || null;
             	this.scope = scope || null;
             	this.fn = fn || function(){};
             	this.className = className || null;
             }
             jsCombo.prototype.draw = function() {
             	if (!this.scope || !this.options) return null;
             	var select = document.createElement('select');
             	if (this.className) select.className = className;
             	select.title = this.title;
             	for (var o in this.options) {
             		//var opt = this.options[o];
             		var option = document.createElement('option');
             		option.value = o;
             		option.appendChild(document.createTextNode(this.options[o]));
             		select.appendChild(option);
             	}
             	var This = this;
             	select.onchange = function() {
             		try {
             			This.fn.call(This.scope, this.value);
             		} catch (e) { alert(e); }
             		return false;
             	}
             	return select;
             }
             jsToolBar.prototype = {
             	base_url: '',
             	mode: 'wiki',
             	elements: {},
             	help_link: '',
             	getMode: function() {
             		return this.mode;
             	},
             	setMode: function(mode) {
             		this.mode = mode || 'wiki';
             	},
             	switchMode: function(mode) {
             		mode = mode || 'wiki';
             		this.draw(mode);
             	},
             	setHelpLink: function(link) {
             		this.help_link = link;
             	},
             	button: function(toolName) {
             		var tool = this.elements[toolName];
             		if (typeof tool.fn[this.mode] != 'function') return null;
             		var b = new jsButton(tool.title, tool.fn[this.mode], this, 'jstb_'+toolName);
             		if (tool.icon != undefined) b.icon = tool.icon;
             		return b;
             	},
             	space: function(toolName) {
             		var tool = new jsSpace(toolName)
             		if (this.elements[toolName].width !== undefined)
             			tool.width = this.elements[toolName].width;
             		return tool;
             	},
             	combo: function(toolName) {
             		var tool = this.elements[toolName];
             		var length = tool[this.mode].list.length;
             		if (typeof tool[this.mode].fn != 'function' || length == 0) {
             			return null;
             		} else {
             			var options = {};
             			for (var i=0; i < length; i++) {
             				var opt = tool[this.mode].list[i];
             				options[opt] = tool.options[opt];
             			}
             			return new jsCombo(tool.title, options, this, tool[this.mode].fn);
             		}
             	},
             	draw: function(mode) {
             		this.setMode(mode);
             		// Empty toolbar
             		while (this.toolbar.hasChildNodes()) {
             			this.toolbar.removeChild(this.toolbar.firstChild)
             		}
             		this.toolNodes = {}; // vide les raccourcis DOM/**/
             		var h = document.createElement('div');
             		h.className = 'help'
             		h.innerHTML = this.help_link;
             		'<a href="/help/wiki_syntax.html" onclick="window.open(\'/help/wiki_syntax.html\', \'\', \'resizable=yes, location=no, width=300, height=640, menubar=no, status=no, scrollbars=yes\'); return false;">Aide</a>';
             		this.toolbar.appendChild(h);
             		// Draw toolbar elements
             		var b, tool, newTool;
             		for (var i in this.elements) {
             			b = this.elements[i];
             			var disabled =
             			b.type == undefined || b.type == ''
             			|| (b.disabled != undefined && b.disabled)
             			|| (b.context != undefined && b.context != null && b.context != this.context);
             			if (!disabled && typeof this[b.type] == 'function') {
             				tool = this[b.type](i);
             				if (tool) newTool = tool.draw();
             				if (newTool) {
             					this.toolNodes[i] = newTool; //mémorise l'accès DOM pour usage éventuel ultérieur
             					this.toolbar.appendChild(newTool);
             				}
             			}
             		}
             	},
             	singleTag: function(stag,etag) {
             		stag = stag || null;
             		etag = etag || stag;
             		if (!stag || !etag) { return; }
             		this.encloseSelection(stag,etag);
             	},
             	encloseLineSelection: function(prefix, suffix, fn) {
             		this.textarea.focus();
             		prefix = prefix || '';
             		suffix = suffix || '';
             		var start, end, sel, scrollPos, subst, res;
             		if (typeof(document["selection"]) != "undefined") {
             			sel = document.selection.createRange().text;
             		} else if (typeof(this.textarea["setSelectionRange"]) != "undefined") {
             			start = this.textarea.selectionStart;
             			end = this.textarea.selectionEnd;
             			scrollPos = this.textarea.scrollTop;
             			// go to the start of the line
             			start = this.textarea.value.substring(0, start).replace(/[^\r\n]*$/g,'').length;
             			// go to the end of the line
                         end = this.textarea.value.length - this.textarea.value.substring(end, this.textarea.value.length).replace(/^[^\r\n]*/, '').length;
             			sel = this.textarea.value.substring(start, end);
             		}
             		if (sel.match(/ $/)) { // exclude ending space char, if any
             			sel = sel.substring(0, sel.length - 1);
             			suffix = suffix + " ";
             		}
             		if (typeof(fn) == 'function') {
             			res = (sel) ? fn.call(this,sel) : fn('');
             		} else {
             			res = (sel) ? sel : '';
             		}
             		subst = prefix + res + suffix;
             		if (typeof(document["selection"]) != "undefined") {
             			document.selection.createRange().text = subst;
             			var range = this.textarea.createTextRange();
             			range.collapse(false);
             			range.move('character', -suffix.length);
             			range.select();
             		} else if (typeof(this.textarea["setSelectionRange"]) != "undefined") {
             			this.textarea.value = this.textarea.value.substring(0, start) + subst +
             			this.textarea.value.substring(end);
             			if (sel) {
             				this.textarea.setSelectionRange(start + subst.length, start + subst.length);
             			} else {
             				this.textarea.setSelectionRange(start + prefix.length, start + prefix.length);
             			}
             			this.textarea.scrollTop = scrollPos;
             		}
             	},
             	encloseSelection: function(prefix, suffix, fn) {
             		this.textarea.focus();
             		prefix = prefix || '';
             		suffix = suffix || '';
             		var start, end, sel, scrollPos, subst, res;
             		if (typeof(document["selection"]) != "undefined") {
             			sel = document.selection.createRange().text;
             		} else if (typeof(this.textarea["setSelectionRange"]) != "undefined") {
             			start = this.textarea.selectionStart;
             			end = this.textarea.selectionEnd;
             			scrollPos = this.textarea.scrollTop;
             			sel = this.textarea.value.substring(start, end);
             		}
             		if (sel.match(/ $/)) { // exclude ending space char, if any
             			sel = sel.substring(0, sel.length - 1);
             			suffix = suffix + " ";
             		}
             		if (typeof(fn) == 'function') {
             			res = (sel) ? fn.call(this,sel) : fn('');
             		} else {
             			res = (sel) ? sel : '';
             		}
             		subst = prefix + res + suffix;
             		if (typeof(document["selection"]) != "undefined") {
             			document.selection.createRange().text = subst;
             			var range = this.textarea.createTextRange();
             			range.collapse(false);
             			range.move('character', -suffix.length);
             			range.select();
             //			this.textarea.caretPos -= suffix.length;
             		} else if (typeof(this.textarea["setSelectionRange"]) != "undefined") {
             			this.textarea.value = this.textarea.value.substring(0, start) + subst +
             			this.textarea.value.substring(end);
             			if (sel) {
             				this.textarea.setSelectionRange(start + subst.length, start + subst.length);
             			} else {
             				this.textarea.setSelectionRange(start + prefix.length, start + prefix.length);
             			}
             			this.textarea.scrollTop = scrollPos;
             		}
             	},
             	stripBaseURL: function(url) {
             		if (this.base_url != '') {
             			var pos = url.indexOf(this.base_url);
             			if (pos == 0) {
             				url = url.substr(this.base_url.length);
             			}
             		}
             		return url;
             	}
             };
             /** Resizer
             -------------------------------------------------------- */
             jsToolBar.prototype.resizeSetStartH = function() {
             	this.dragStartH = this.textarea.offsetHeight + 0;
             };
             jsToolBar.prototype.resizeDragStart = function(event) {
             	var This = this;
             	this.dragStartY = event.clientY;
             	this.resizeSetStartH();
             	document.addEventListener('mousemove', this.dragMoveHdlr=function(event){This.resizeDragMove(event);}, false);
             	document.addEventListener('mouseup', this.dragStopHdlr=function(event){This.resizeDragStop(event);}, false);
             };
             jsToolBar.prototype.resizeDragMove = function(event) {
             	this.textarea.style.height = (this.dragStartH+event.clientY-this.dragStartY)+'px';
             };
             jsToolBar.prototype.resizeDragStop = function(event) {
             	document.removeEventListener('mousemove', this.dragMoveHdlr, false);
             	document.removeEventListener('mouseup', this.dragStopHdlr, false);
             };
-            // Elements definition ------------------------------------
-            // strong
-            jsToolBar.prototype.elements.strong = {
-            	type: 'button',
-            	title: 'Strong',
-            	fn: {
-            		wiki: function() { this.singleTag('*') }
-            // em
-            jsToolBar.prototype.elements.em = {
-            	type: 'button',
-            	title: 'Italic',
-            	fn: {
-            		wiki: function() { this.singleTag("_") }
-            // ins
-            jsToolBar.prototype.elements.ins = {
-            	type: 'button',
-            	title: 'Underline',
-            	fn: {
-            		wiki: function() { this.singleTag('+') }
-            // del
-            jsToolBar.prototype.elements.del = {
-            	type: 'button',
-            	title: 'Deleted',
-            	fn: {
-            		wiki: function() { this.singleTag('-') }
-            // code
-            jsToolBar.prototype.elements.code = {
-            	type: 'button',
-            	title: 'Code',
-            	fn: {
-            		wiki: function() { this.singleTag('@') }
-            // spacer
-            jsToolBar.prototype.elements.space1 = {type: 'space'}
-            // headings
-            jsToolBar.prototype.elements.h1 = {
-            	type: 'button',
-            	title: 'Heading 1',
-            	fn: {
-            		wiki: function() {
-            		  this.encloseLineSelection('h1. ', '',function(str) {
-            		    str = str.replace(/^h\d+\.\s+/, '')
-            		    return str;
-            		  });
-            jsToolBar.prototype.elements.h2 = {
-            	type: 'button',
-            	title: 'Heading 2',
-            	fn: {
-            		wiki: function() {
-            		  this.encloseLineSelection('h2. ', '',function(str) {
-            		    str = str.replace(/^h\d+\.\s+/, '')
-            		    return str;
-            		  });
-            jsToolBar.prototype.elements.h3 = {
-            	type: 'button',
-            	title: 'Heading 3',
-            	fn: {
-            		wiki: function() {
-            		  this.encloseLineSelection('h3. ', '',function(str) {
-            		    str = str.replace(/^h\d+\.\s+/, '')
-            		    return str;
-            		  });
-            // spacer
-            jsToolBar.prototype.elements.space2 = {type: 'space'}
-            // ul
-            jsToolBar.prototype.elements.ul = {
-            	type: 'button',
-            	title: 'Unordered list',
-            	fn: {
-            		wiki: function() {
-            			this.encloseLineSelection('','',function(str) {
-            				str = str.replace(/\r/g,'');
-            				return str.replace(/(\n|^)[#-]?\s*/g,"$1* ");
-            			});
-            // ol
-            jsToolBar.prototype.elements.ol = {
-            	type: 'button',
-            	title: 'Ordered list',
-            	fn: {
-            		wiki: function() {
-            			this.encloseLineSelection('','',function(str) {
-            				str = str.replace(/\r/g,'');
-            				return str.replace(/(\n|^)[*-]?\s*/g,"$1# ");
-            			});
-            // spacer
-            jsToolBar.prototype.elements.space3 = {type: 'space'}
-            // bq
-            jsToolBar.prototype.elements.bq = {
-            	type: 'button',
-            	title: 'Quote',
-            	fn: {
-            		wiki: function() {
-            			this.encloseLineSelection('','',function(str) {
-            				str = str.replace(/\r/g,'');
-            				return str.replace(/(\n|^) *([^\n]*)/g,"$1> $2");
-            			});
-            // unbq
-            jsToolBar.prototype.elements.unbq = {
-            	type: 'button',
-            	title: 'Unquote',
-            	fn: {
-            		wiki: function() {
-            			this.encloseLineSelection('','',function(str) {
-            				str = str.replace(/\r/g,'');
-            				return str.replace(/(\n|^) *[>]? *([^\n]*)/g,"$1$2");
-            			});
-            // pre
-            jsToolBar.prototype.elements.pre = {
-            	type: 'button',
-            	title: 'Preformatted text',
-            	fn: {
-            		wiki: function() { this.encloseLineSelection('<pre>\n', '\n</pre>') }
-            // spacer
-            jsToolBar.prototype.elements.space4 = {type: 'space'}
-            // wiki page
-            jsToolBar.prototype.elements.link = {
-            	type: 'button',
-            	title: 'Wiki link',
-            	fn: {
-            		wiki: function() { this.encloseSelection("[[", "]]") }
-            // image
-            jsToolBar.prototype.elements.img = {
-            	type: 'button',
-            	title: 'Image',
-            	fn: {
-            		wiki: function() { this.encloseSelection("!", "!") }

test/unit/helpers/application_helper_test.rb +7 0

             # redMine - project management software
             # Copyright (C) 2006-2007  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.dirname(__FILE__) + '/../../test_helper'
             class ApplicationHelperTest < HelperTestCase
               include ApplicationHelper
               include ActionView::Helpers::TextHelper
               fixtures :projects, :roles, :enabled_modules,
                                   :repositories, :changesets,
                                   :trackers, :issue_statuses, :issues, :versions, :documents,
                                   :wikis, :wiki_pages, :wiki_contents,
                                   :boards, :messages
               def setup
                 super
               end
               def test_auto_links
                 to_test = {
                   'http://foo.bar' => '<a class="external" href="http://foo.bar">http://foo.bar</a>',
                   'http://foo.bar/~user' => '<a class="external" href="http://foo.bar/~user">http://foo.bar/~user</a>',
                   'http://foo.bar.' => '<a class="external" href="http://foo.bar">http://foo.bar</a>.',
                   'This is a link: http://foo.bar.' => 'This is a link: <a class="external" href="http://foo.bar">http://foo.bar</a>.',
                   'A link (eg. http://foo.bar).' => 'A link (eg. <a class="external" href="http://foo.bar">http://foo.bar</a>).',
                   'http://foo.bar/foo.bar#foo.bar.' => '<a class="external" href="http://foo.bar/foo.bar#foo.bar">http://foo.bar/foo.bar#foo.bar</a>.',
                   'http://www.foo.bar/Test_(foobar)' => '<a class="external" href="http://www.foo.bar/Test_(foobar)">http://www.foo.bar/Test_(foobar)</a>',
                   '(see inline link : http://www.foo.bar/Test_(foobar))' => '(see inline link : <a class="external" href="http://www.foo.bar/Test_(foobar)">http://www.foo.bar/Test_(foobar)</a>)',
                   '(see inline link : http://www.foo.bar/Test)' => '(see inline link : <a class="external" href="http://www.foo.bar/Test">http://www.foo.bar/Test</a>)',
                   '(see inline link : http://www.foo.bar/Test).' => '(see inline link : <a class="external" href="http://www.foo.bar/Test">http://www.foo.bar/Test</a>).',
                   '(see "inline link":http://www.foo.bar/Test_(foobar))' => '(see <a href="http://www.foo.bar/Test_(foobar)" class="external">inline link</a>)',
                   '(see "inline link":http://www.foo.bar/Test)' => '(see <a href="http://www.foo.bar/Test" class="external">inline link</a>)',
                   '(see "inline link":http://www.foo.bar/Test).' => '(see <a href="http://www.foo.bar/Test" class="external">inline link</a>).',
                   'www.foo.bar' => '<a class="external" href="http://www.foo.bar">www.foo.bar</a>',
                   'http://foo.bar/page?p=1&t=z&s=' => '<a class="external" href="http://foo.bar/page?p=1&#38;t=z&#38;s=">http://foo.bar/page?p=1&#38;t=z&#38;s=</a>',
                   'http://foo.bar/page#125' => '<a class="external" href="http://foo.bar/page#125">http://foo.bar/page#125</a>',
                   'http://foo@www.bar.com' => '<a class="external" href="http://foo@www.bar.com">http://foo@www.bar.com</a>',
                   'http://foo:bar@www.bar.com' => '<a class="external" href="http://foo:bar@www.bar.com">http://foo:bar@www.bar.com</a>',
                   'ftp://foo.bar' => '<a class="external" href="ftp://foo.bar">ftp://foo.bar</a>',
                 }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_auto_mailto
                 assert_equal '<p><a href="mailto:test@foo.bar" class="email">test@foo.bar</a></p>',
                   textilizable('test@foo.bar')
               end
               def test_inline_images
                 to_test = {
                   '!http://foo.bar/image.jpg!' => '<img src="http://foo.bar/image.jpg" alt="" />',
                   'floating !>http://foo.bar/image.jpg!' => 'floating <div style="float:right"><img src="http://foo.bar/image.jpg" alt="" /></div>',
                   'with class !(some-class)http://foo.bar/image.jpg!' => 'with class <img src="http://foo.bar/image.jpg" class="some-class" alt="" />',
                   'with style !{width:100px;height100px}http://foo.bar/image.jpg!' => 'with style <img src="http://foo.bar/image.jpg" style="width:100px;height100px;" alt="" />',
                 }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_textile_external_links
                 to_test = {
                   'This is a "link":http://foo.bar' => 'This is a <a href="http://foo.bar" class="external">link</a>',
                   'This is an intern "link":/foo/bar' => 'This is an intern <a href="/foo/bar">link</a>',
                   '"link (Link title)":http://foo.bar' => '<a href="http://foo.bar" title="Link title" class="external">link</a>',
                   "This is not a \"Link\":\n\nAnother paragraph" => "This is not a \"Link\":</p>\n\n\n\t<p>Another paragraph",
                   # no multiline link text
                   "This is a double quote \"on the first line\nand another on a second line\":test" => "This is a double quote \"on the first line<br />\nand another on a second line\":test"
                 }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_redmine_links
                 issue_link = link_to('#3', {:controller => 'issues', :action => 'show', :id => 3},
                                            :class => 'issue', :title => 'Error 281 when updating a recipe (New)')
                 changeset_link = link_to('r1', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 1},
                                                :class => 'changeset', :title => 'My very first commit')
                 document_link = link_to('Test document', {:controller => 'documents', :action => 'show', :id => 1},
                                                          :class => 'document')
                 version_link = link_to('1.0', {:controller => 'versions', :action => 'show', :id => 2},
                                               :class => 'version')
                 message_url = {:controller => 'messages', :action => 'show', :board_id => 1, :id => 4}
                 source_url = {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :path => ['some', 'file']}
                 source_url_with_ext = {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :path => ['some', 'file.ext']}
                 to_test = {
                   # tickets
                   '#3, #3 and #3.'              => "#{issue_link}, #{issue_link} and #{issue_link}.",
                   # changesets
                   'r1'                          => changeset_link,
                   # documents
                   'document#1'                  => document_link,
                   'document:"Test document"'    => document_link,
                   # versions
                   'version#2'                   => version_link,
                   'version:1.0'                 => version_link,
                   'version:"1.0"'               => version_link,
                   # source
                   'source:/some/file'           => link_to('source:/some/file', source_url, :class => 'source'),
                   'source:/some/file.'          => link_to('source:/some/file', source_url, :class => 'source') + ".",
                   'source:/some/file.ext.'      => link_to('source:/some/file.ext', source_url_with_ext, :class => 'source') + ".",
                   'source:/some/file. '         => link_to('source:/some/file', source_url, :class => 'source') + ".",
                   'source:/some/file.ext. '     => link_to('source:/some/file.ext', source_url_with_ext, :class => 'source') + ".",
                   'source:/some/file, '         => link_to('source:/some/file', source_url, :class => 'source') + ",",
                   'source:/some/file@52'        => link_to('source:/some/file@52', source_url.merge(:rev => 52), :class => 'source'),
                   'source:/some/file.ext@52'    => link_to('source:/some/file.ext@52', source_url_with_ext.merge(:rev => 52), :class => 'source'),
                   'source:/some/file#L110'      => link_to('source:/some/file#L110', source_url.merge(:anchor => 'L110'), :class => 'source'),
                   'source:/some/file.ext#L110'  => link_to('source:/some/file.ext#L110', source_url_with_ext.merge(:anchor => 'L110'), :class => 'source'),
                   'source:/some/file@52#L110'   => link_to('source:/some/file@52#L110', source_url.merge(:rev => 52, :anchor => 'L110'), :class => 'source'),
                   'export:/some/file'           => link_to('export:/some/file', source_url.merge(:format => 'raw'), :class => 'source download'),
                   # message
                   'message#4'                   => link_to('Post 2', message_url, :class => 'message'),
                   'message#5'                   => link_to('RE: post 2', message_url.merge(:anchor => 'message-5'), :class => 'message'),
                   # escaping
                   '!#3.'                        => '#3.',
                   '!r1'                         => 'r1',
                   '!document#1'                 => 'document#1',
                   '!document:"Test document"'   => 'document:"Test document"',
                   '!version#2'                  => 'version#2',
                   '!version:1.0'                => 'version:1.0',
                   '!version:"1.0"'              => 'version:"1.0"',
                   '!source:/some/file'          => 'source:/some/file',
                   # invalid expressions
                   'source:'                     => 'source:',
                   # url hash
                   "http://foo.bar/FAQ#3"       => '<a class="external" href="http://foo.bar/FAQ#3">http://foo.bar/FAQ#3</a>',
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_wiki_links
                 to_test = {
                   '[[CookBook documentation]]' => '<a href="/wiki/ecookbook/CookBook_documentation" class="wiki-page">CookBook documentation</a>',
                   '[[Another page|Page]]' => '<a href="/wiki/ecookbook/Another_page" class="wiki-page">Page</a>',
                   # link with anchor
                   '[[CookBook documentation#One-section]]' => '<a href="/wiki/ecookbook/CookBook_documentation#One-section" class="wiki-page">CookBook documentation</a>',
                   '[[Another page#anchor|Page]]' => '<a href="/wiki/ecookbook/Another_page#anchor" class="wiki-page">Page</a>',
                   # page that doesn't exist
                   '[[Unknown page]]' => '<a href="/wiki/ecookbook/Unknown_page" class="wiki-page new">Unknown page</a>',
                   '[[Unknown page|404]]' => '<a href="/wiki/ecookbook/Unknown_page" class="wiki-page new">404</a>',
                   # link to another project wiki
                   '[[onlinestore:]]' => '<a href="/wiki/onlinestore/" class="wiki-page">onlinestore</a>',
                   '[[onlinestore:|Wiki]]' => '<a href="/wiki/onlinestore/" class="wiki-page">Wiki</a>',
                   '[[onlinestore:Start page]]' => '<a href="/wiki/onlinestore/Start_page" class="wiki-page">Start page</a>',
                   '[[onlinestore:Start page|Text]]' => '<a href="/wiki/onlinestore/Start_page" class="wiki-page">Text</a>',
                   '[[onlinestore:Unknown page]]' => '<a href="/wiki/onlinestore/Unknown_page" class="wiki-page new">Unknown page</a>',
                   # striked through link
                   '-[[Another page|Page]]-' => '<del><a href="/wiki/ecookbook/Another_page" class="wiki-page">Page</a></del>',
                   # escaping
                   '![[Another page|Page]]' => '[[Another page|Page]]',
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_html_tags
                 to_test = {
                   "<div>content</div>" => "<p>&lt;div&gt;content&lt;/div&gt;</p>",
                   "<div class=\"bold\">content</div>" => "<p>&lt;div class=\"bold\"&gt;content&lt;/div&gt;</p>",
                   "<script>some script;</script>" => "<p>&lt;script&gt;some script;&lt;/script&gt;</p>",
                   # do not escape pre/code tags
                   "<pre>\nline 1\nline2</pre>" => "<pre>\nline 1\nline2</pre>",
                   "<pre><code>\nline 1\nline2</code></pre>" => "<pre><code>\nline 1\nline2</code></pre>",
                   "<pre><div>content</div></pre>" => "<pre>&lt;div&gt;content&lt;/div&gt;</pre>",
                   "HTML comment: <!-- no comments -->" => "<p>HTML comment: &lt;!-- no comments --&gt;</p>",
                   "<!-- opening comment" => "<p>&lt;!-- opening comment</p>",
                   # remove attributes
                   "<pre class='foo'>some text</pre>" => "<pre>some text</pre>",
                 }
                 to_test.each { |text, result| assert_equal result, textilizable(text) }
               end
               def test_allowed_html_tags
                 to_test = {
                   "<pre>preformatted text</pre>" => "<pre>preformatted text</pre>",
                   "<notextile>no *textile* formatting</notextile>" => "no *textile* formatting",
                   "<notextile>this is <tag>a tag</tag></notextile>" => "this is &lt;tag&gt;a tag&lt;/tag&gt;"
                 }
                 to_test.each { |text, result| assert_equal result, textilizable(text) }
               end
               def test_wiki_links_in_tables
                 to_test = {"|[[Page|Link title]]|[[Other Page|Other title]]|\n|Cell 21|[[Last page]]|" =>
                              '<tr><td><a href="/wiki/ecookbook/Page" class="wiki-page new">Link title</a></td>' +
                              '<td><a href="/wiki/ecookbook/Other_Page" class="wiki-page new">Other title</a></td>' +
                              '</tr><tr><td>Cell 21</td><td><a href="/wiki/ecookbook/Last_page" class="wiki-page new">Last page</a></td></tr>'
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<table>#{result}</table>", textilizable(text).gsub(/[\t\n]/, '') }
               end
               def test_text_formatting
                 to_test = {'*_+bold, italic and underline+_*' => '<strong><em><ins>bold, italic and underline</ins></em></strong>',
                            '(_text within parentheses_)' => '(<em>text within parentheses</em>)'
                           }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_wiki_horizontal_rule
                 assert_equal '<hr />', textilizable('---')
                 assert_equal '<p>Dashes: ---</p>', textilizable('Dashes: ---')
               end
               def test_footnotes
                 raw = <<-RAW
             This is some text[1].
             fn1. This is the foot note
             RAW
                 expected = <<-EXPECTED
             <p>This is some text<sup><a href=\"#fn1\">1</a></sup>.</p>
             <p id="fn1" class="footnote"><sup>1</sup> This is the foot note</p>
             EXPECTED
                 assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
               end
               def test_table_of_content
                 raw = <<-RAW
             {{toc}}
             h1. Title
             Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
             h2. Subtitle
             Nullam commodo metus accumsan nulla. Curabitur lobortis dui id dolor.
             h2. Subtitle with %{color:red}red text%
             h1. Another title
             RAW
                 expected = '<ul class="toc">' +
                            '<li class="heading1"><a href="#Title">Title</a></li>' +
                            '<li class="heading2"><a href="#Subtitle">Subtitle</a></li>' +
                            '<li class="heading2"><a href="#Subtitle-with-red-text">Subtitle with red text</a></li>' +
                            '<li class="heading1"><a href="#Another-title">Another title</a></li>' +
                            '</ul>'
                 assert textilizable(raw).gsub("\n", "").include?(expected)
               end
               def test_blockquote
                 # orig raw text
                 raw = <<-RAW
             John said:
             > Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
             > Nullam commodo metus accumsan nulla. Curabitur lobortis dui id dolor.
             > * Donec odio lorem,
             > * sagittis ac,
             > * malesuada in,
             > * adipiscing eu, dolor.
             >
             > >Nulla varius pulvinar diam. Proin id arcu id lorem scelerisque condimentum. Proin vehicula turpis vitae lacus.
             > Proin a tellus. Nam vel neque.
             He's right.
             RAW
                 # expected html
                 expected = <<-EXPECTED
             <p>John said:</p>
             <blockquote>
             Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
             Nullam commodo metus accumsan nulla. Curabitur lobortis dui id dolor.
             <ul>
               <li>Donec odio lorem,</li>
               <li>sagittis ac,</li>
               <li>malesuada in,</li>
               <li>adipiscing eu, dolor.</li>
             </ul>
             <blockquote>
             <p>Nulla varius pulvinar diam. Proin id arcu id lorem scelerisque condimentum. Proin vehicula turpis vitae lacus.</p>
             </blockquote>
             <p>Proin a tellus. Nam vel neque.</p>
             </blockquote>
             <p>He's right.</p>
             EXPECTED
                 assert_equal expected.gsub(%r{\s+}, ''), textilizable(raw).gsub(%r{\s+}, '')
               end
               def test_table
                 raw = <<-RAW
             This is a table with empty cells:
             |cell11|cell12||
             |cell21||cell23|
             |cell31|cell32|cell33|
             RAW
                 expected = <<-EXPECTED
             <p>This is a table with empty cells:</p>
             <table>
               <tr><td>cell11</td><td>cell12</td><td></td></tr>
               <tr><td>cell21</td><td></td><td>cell23</td></tr>
               <tr><td>cell31</td><td>cell32</td><td>cell33</td></tr>
             </table>
             EXPECTED
                 assert_equal expected.gsub(%r{\s+}, ''), textilizable(raw).gsub(%r{\s+}, '')
               end
               def test_macro_hello_world
                 text = "{{hello_world}}"
                 assert textilizable(text).match(/Hello world!/)
                 # escaping
                 text = "!{{hello_world}}"
                 assert_equal '<p>{{hello_world}}</p>', textilizable(text)
               end
               def test_macro_include
                 @project = Project.find(1)
                 # include a page of the current project wiki
                 text = "{{include(Another page)}}"
                 assert textilizable(text).match(/This is a link to a ticket/)
                 @project = nil
                 # include a page of a specific project wiki
                 text = "{{include(ecookbook:Another page)}}"
                 assert textilizable(text).match(/This is a link to a ticket/)
                 text = "{{include(ecookbook:)}}"
                 assert textilizable(text).match(/CookBook documentation/)
                 text = "{{include(unknowidentifier:somepage)}}"
                 assert textilizable(text).match(/Unknow project/)
               end
+              def test_default_formatter
+                Setting.text_formatting = 'unknown'
+                text = 'a *link*: http://www.example.net/'
+                assert_equal '<p>a *link*: <a href="http://www.example.net/">http://www.example.net/</a></p>', textilizable(text)
+                Setting.text_formatting = 'textile'
+              end
               def test_date_format_default
                 today = Date.today
                 Setting.date_format = ''
                 assert_equal l_date(today), format_date(today)
               end
               def test_date_format
                 today = Date.today
                 Setting.date_format = '%d %m %Y'
                 assert_equal today.strftime('%d %m %Y'), format_date(today)
               end
               def test_time_format_default
                 now = Time.now
                 Setting.date_format = ''
                 Setting.time_format = ''
                 assert_equal l_datetime(now), format_time(now)
                 assert_equal l_time(now), format_time(now, false)
               end
               def test_time_format
                 now = Time.now
                 Setting.date_format = '%d %m %Y'
                 Setting.time_format = '%H %M'
                 assert_equal now.strftime('%d %m %Y %H %M'), format_time(now)
                 assert_equal now.strftime('%H %M'), format_time(now, false)
               end
               def test_utc_time_format
                 now = Time.now.utc
                 Setting.date_format = '%d %m %Y'
                 Setting.time_format = '%H %M'
                 assert_equal Time.now.strftime('%d %m %Y %H %M'), format_time(now)
                 assert_equal Time.now.strftime('%H %M'), format_time(now, false)
               end
               def test_due_date_distance_in_words
                 to_test = { Date.today => 'Due in 0 days',
                             Date.today + 1 => 'Due in 1 day',
                             Date.today + 100 => 'Due in 100 days',
                             Date.today + 20000 => 'Due in 20000 days',
                             Date.today - 1 => '1 day late',
                             Date.today - 100 => '100 days late',
                             Date.today - 20000 => '20000 days late',
                            }
                 to_test.each do |date, expected|
                   assert_equal expected, due_date_distance_in_words(date)
                 end
               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