jro_apps/redmine Commit - r12177:471e01ca5059

Adds experimental support for Markdown formatting with redcarpet (#15520)....

Jean-Philippe Lang -

r12177:471e01ca5059

parent child

Context file:

r12177:471e01ca5059

Collapse all files

lib/redmine/wiki_formatting/markdown/formatter.rb created 644 +136 0

@@ -0,0 +1,136
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2013 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 'cgi'
	19
	20	module Redmine
	21	module WikiFormatting
	22	module Markdown
	23	class HTML < Redcarpet::Render::HTML
	24	include ActionView::Helpers::TagHelper
	25
	26	def link(link, title, content)
	27	css = nil
	28	unless link && link.starts_with?('/')
	29	css = 'external'
	30	end
	31	content_tag('a', content.html_safe, :href => link, :title => title, :class => css)
	32	end
	33
	34	def block_code(code, language)
	35	if language.present?
	36	"<pre><code class=\"#{CGI.escapeHTML language} syntaxhl\">" +
	37	Redmine::SyntaxHighlighting.highlight_by_language(code, language) +
	38	"</code></pre>"
	39	else
	40	"<pre>" + CGI.escapeHTML(code) + "</pre>"
	41	end
	42	end
	43	end
	44
	45	class Formatter
	46	def initialize(text)
	47	@text = text
	48	end
	49
	50	def to_html(*args)
	51	html = formatter.render(@text)
	52	# restore wiki links eg. [[Foo]]
	53	html.gsub!(%r{\[<a href="(.?)">(.?)</a>\]}) do
	54	"[[#{$2}]]"
	55	end
	56	# restore Redmine links with double-quotes, eg. version:"1.0"
	57	html.gsub!(/(\w):"(.+?)"/) do
	58	"#{$1}:\"#{$2}\""
	59	end
	60	html
	61	end
	62
	63	def get_section(index)
	64	section = extract_sections(index)[1]
	65	hash = Digest::MD5.hexdigest(section)
	66	return section, hash
	67	end
	68
	69	def update_section(index, update, hash=nil)
	70	t = extract_sections(index)
	71	if hash.present? && hash != Digest::MD5.hexdigest(t[1])
	72	raise Redmine::WikiFormatting::StaleSectionError
	73	end
	74	t[1] = update unless t[1].blank?
	75	t.reject(&:blank?).join "\n\n"
	76	end
	77
	78	def extract_sections(index)
	79	sections = ['', '', '']
	80	offset = 0
	81	i = 0
	82	l = 1
	83	inside_pre = false
	84	@text.split(/(^(?:.+\r?\n\r?(?:\=+\|\-+)\|#+.+\|~~~.)\s$)/).each do \|part\|
	85	level = nil
	86	if part =~ /\A~{3,}(\S+)?\s*$/
	87	if $1
	88	if !inside_pre
	89	inside_pre = true
	90	end
	91	else
	92	inside_pre = !inside_pre
	93	end
	94	elsif inside_pre
	95	# nop
	96	elsif part =~ /\A(#+).+/
	97	level = $1.size
	98	elsif part =~ /\A.+\r?\n\r?(\=+\|\-+)\s*$/
	99	level = $1.include?('=') ? 1 : 2
	100	end
	101	if level
	102	i += 1
	103	if offset == 0 && i == index
	104	# entering the requested section
	105	offset = 1
	106	l = level
	107	elsif offset == 1 && i > index && level <= l
	108	# leaving the requested section
	109	offset = 2
	110	end
	111	end
	112	sections[offset] << part
	113	end
	114	sections.map(&:strip)
	115	end
	116
	117	private
	118
	119	def formatter
	120	@@formatter \|\|= Redcarpet::Markdown.new(
	121	Redmine::WikiFormatting::Markdown::HTML.new(
	122	:filter_html => true,
	123	:hard_wrap => true
	124	),
	125	:autolink => true,
	126	:fenced_code_blocks => true,
	127	:space_after_headers => true,
	128	:tables => true,
	129	:strikethrough => true,
	130	:superscript => true
	131	)
	132	end
	133	end
	134	end
	135	end
	136	end

lib/redmine/wiki_formatting/markdown/helper.rb created 644 +45 0

@@ -0,0 +1,45
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2013 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 Markdown
	21	module Helper
	22	def wikitoolbar_for(field_id)
	23	heads_for_wiki_formatter
	24	javascript_tag("var wikiToolbar = new jsToolBar(document.getElementById('#{field_id}')); wikiToolbar.draw();")
	25	end
	26
	27	def initial_page_content(page)
	28	"# #{@page.pretty_title}"
	29	end
	30
	31	def heads_for_wiki_formatter
	32	unless @heads_for_wiki_formatter_included
	33	content_for :header_tags do
	34	javascript_include_tag('jstoolbar/jstoolbar') +
	35	javascript_include_tag('jstoolbar/markdown') +
	36	javascript_include_tag("jstoolbar/lang/jstoolbar-#{current_language.to_s.downcase}") +
	37	stylesheet_link_tag('jstoolbar')
	38	end
	39	@heads_for_wiki_formatter_included = true
	40	end
	41	end
	42	end
	43	end
	44	end
	45	end

public/javascripts/jstoolbar/markdown.js created 644 +194 0

@@ -0,0 +1,194
	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 markdown 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	// del
	44	jsToolBar.prototype.elements.del = {
	45	type: 'button',
	46	title: 'Deleted',
	47	fn: {
	48	wiki: function() { this.singleTag('~~') }
	49	}
	50	}
	51
	52	// code
	53	jsToolBar.prototype.elements.code = {
	54	type: 'button',
	55	title: 'Code',
	56	fn: {
	57	wiki: function() { this.singleTag('`') }
	58	}
	59	}
	60
	61	// spacer
	62	jsToolBar.prototype.elements.space1 = {type: 'space'}
	63
	64	// headings
	65	jsToolBar.prototype.elements.h1 = {
	66	type: 'button',
	67	title: 'Heading 1',
	68	fn: {
	69	wiki: function() {
	70	this.encloseLineSelection('# ', '',function(str) {
	71	str = str.replace(/^#+\s+/, '')
	72	return str;
	73	});
	74	}
	75	}
	76	}
	77	jsToolBar.prototype.elements.h2 = {
	78	type: 'button',
	79	title: 'Heading 2',
	80	fn: {
	81	wiki: function() {
	82	this.encloseLineSelection('## ', '',function(str) {
	83	str = str.replace(/^#+\s+/, '')
	84	return str;
	85	});
	86	}
	87	}
	88	}
	89	jsToolBar.prototype.elements.h3 = {
	90	type: 'button',
	91	title: 'Heading 3',
	92	fn: {
	93	wiki: function() {
	94	this.encloseLineSelection('### ', '',function(str) {
	95	str = str.replace(/^#+\s+/, '')
	96	return str;
	97	});
	98	}
	99	}
	100	}
	101
	102	// spacer
	103	jsToolBar.prototype.elements.space2 = {type: 'space'}
	104
	105	// ul
	106	jsToolBar.prototype.elements.ul = {
	107	type: 'button',
	108	title: 'Unordered list',
	109	fn: {
	110	wiki: function() {
	111	this.encloseLineSelection('','',function(str) {
	112	str = str.replace(/\r/g,'');
	113	return str.replace(/(\n\|^)[#-]?\s/g,"$1 ");
	114	});
	115	}
	116	}
	117	}
	118
	119	// ol
	120	jsToolBar.prototype.elements.ol = {
	121	type: 'button',
	122	title: 'Ordered list',
	123	fn: {
	124	wiki: function() {
	125	this.encloseLineSelection('','',function(str) {
	126	str = str.replace(/\r/g,'');
	127	return str.replace(/(\n\|^)[-]?\s/g,"$11. ");
	128	});
	129	}
	130	}
	131	}
	132
	133	// spacer
	134	jsToolBar.prototype.elements.space3 = {type: 'space'}
	135
	136	// bq
	137	jsToolBar.prototype.elements.bq = {
	138	type: 'button',
	139	title: 'Quote',
	140	fn: {
	141	wiki: function() {
	142	this.encloseLineSelection('','',function(str) {
	143	str = str.replace(/\r/g,'');
	144	return str.replace(/(\n\|^) ([^\n])/g,"$1> $2");
	145	});
	146	}
	147	}
	148	}
	149
	150	// unbq
	151	jsToolBar.prototype.elements.unbq = {
	152	type: 'button',
	153	title: 'Unquote',
	154	fn: {
	155	wiki: function() {
	156	this.encloseLineSelection('','',function(str) {
	157	str = str.replace(/\r/g,'');
	158	return str.replace(/(\n\|^) [>]? ([^\n]*)/g,"$1$2");
	159	});
	160	}
	161	}
	162	}
	163
	164	// pre
	165	jsToolBar.prototype.elements.pre = {
	166	type: 'button',
	167	title: 'Preformatted text',
	168	fn: {
	169	wiki: function() { this.encloseLineSelection('~~~\n', '\n~~~') }
	170	}
	171	}
	172
	173	// spacer
	174	jsToolBar.prototype.elements.space4 = {type: 'space'}
	175
	176	// wiki page
	177	jsToolBar.prototype.elements.link = {
	178	type: 'button',
	179	title: 'Wiki link',
	180	fn: {
	181	wiki: function() { this.encloseSelection("[[", "]]") }
	182	}
	183	}
	184	// image
	185	jsToolBar.prototype.elements.img = {
	186	type: 'button',
	187	title: 'Image',
	188	fn: {
	189	wiki: function() { this.encloseSelection("![](", ")") }
	190	}
	191	}
	192
	193	// spacer
	194	jsToolBar.prototype.elements.space5 = {type: 'space'}

test/unit/lib/redmine/wiki_formatting/markdown_formatter.rb created 644 +62 0

@@ -0,0 +1,62
	1	# Redmine - project management software
	2	# Copyright (C) 2006-2013 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 File.expand_path('../../../../../test_helper', __FILE__)
	19
	20	class Redmine::WikiFormatting::MarkdownFormatterTest < ActionView::TestCase
	21	include ApplicationHelper
	22
	23	def setup
	24	@formatter = Redmine::WikiFormatting::Markdown::Formatter
	25	end
	26
	27	def test_inline_style
	28	assert_equal "<p><strong>foo</strong></p>", @formatter.new("foo").to_html.strip
	29	end
	30
	31	def test_wiki_links_should_be_preserved
	32	text = 'This is a wiki link: [[Foo]]'
	33	assert_include '[[Foo]]', @formatter.new(text).to_html
	34	end
	35
	36	def test_redmine_links_with_double_quotes_should_be_preserved
	37	text = 'This is a redmine link: version:"1.0"'
	38	assert_include 'version:"1.0"', @formatter.new(text).to_html
	39	end
	40
	41	def test_should_support_syntax_highligth
	42	text = <<-STR
	43	~~~ruby
	44	def foo
	45	end
	46	~~~
	47	STR
	48	assert_select_in @formatter.new(text).to_html, 'pre code.ruby.syntaxhl' do
	49	assert_select 'span.keyword', :text => 'def'
	50	end
	51	end
	52
	53	def test_external_links_should_have_external_css_class
	54	text = 'This is a [link](http://example.net/)'
	55	assert_equal '<p>This is a <a class="external" href="http://example.net/">link</a></p>', @formatter.new(text).to_html.strip
	56	end
	57
	58	def test_locals_links_should_not_have_external_css_class
	59	text = 'This is a [link](/issues)'
	60	assert_equal '<p>This is a <a href="/issues">link</a></p>', @formatter.new(text).to_html.strip
	61	end
	62	end

Gemfile +2 0

             source 'https://rubygems.org'
             gem "rails", "3.2.16"
             gem "jquery-rails", "~> 2.0.2"
             gem "coderay", "~> 1.1.0"
             gem "fastercsv", "~> 1.5.0", :platforms => [:mri_18, :mingw_18, :jruby]
             gem "builder", "3.0.0"
+            # TODO: upgrade to redcarpet 3.x when ruby1.8 support is dropped
+            gem "redcarpet", "~> 2.3.0"
             # Optional gem for LDAP authentication
             group :ldap do
               gem "net-ldap", "~> 0.3.1"
             end
             # Optional gem for OpenID authentication
             group :openid do
               gem "ruby-openid", "~> 2.3.0", :require => "openid"
               gem "rack-openid"
             end
             # Optional gem for exporting the gantt to a PNG file, not supported with jruby
             platforms :mri, :mingw do
               group :rmagick do
                 # RMagick 2 supports ruby 1.9
                 # RMagick 1 would be fine for ruby 1.8 but Bundler does not support
                 # different requirements for the same gem on different platforms
                 gem "rmagick", ">= 2.0.0"
               end
             end
             platforms :jruby do
               # jruby-openssl is bundled with JRuby 1.7.0
               gem "jruby-openssl" if Object.const_defined?(:JRUBY_VERSION) && JRUBY_VERSION < '1.7.0'
               gem "activerecord-jdbc-adapter", "~> 1.3.2"
             end
             # Include database gems for the adapters found in the database
             # configuration file
             require 'erb'
             require 'yaml'
             database_file = File.join(File.dirname(__FILE__), "config/database.yml")
             if File.exist?(database_file)
               database_config = YAML::load(ERB.new(IO.read(database_file)).result)
               adapters = database_config.values.map {|c| c['adapter']}.compact.uniq
               if adapters.any?
                 adapters.each do |adapter|
                   case adapter
                   when 'mysql2'
                     gem "mysql2", "~> 0.3.11", :platforms => [:mri, :mingw]
                     gem "activerecord-jdbcmysql-adapter", :platforms => :jruby
                   when 'mysql'
                     gem "mysql", "~> 2.8.1", :platforms => [:mri, :mingw]
                     gem "activerecord-jdbcmysql-adapter", :platforms => :jruby
                   when /postgresql/
                     gem "pg", ">= 0.11.0", :platforms => [:mri, :mingw]
                     gem "activerecord-jdbcpostgresql-adapter", :platforms => :jruby
                   when /sqlite3/
                     gem "sqlite3", :platforms => [:mri, :mingw]
                     gem "activerecord-jdbcsqlite3-adapter", :platforms => :jruby
                   when /sqlserver/
                     gem "tiny_tds", "~> 0.5.1", :platforms => [:mri, :mingw]
                     gem "activerecord-sqlserver-adapter", :platforms => [:mri, :mingw]
                   else
                     warn("Unknown database adapter `#{adapter}` found in config/database.yml, use Gemfile.local to load your own database gems")
                   end
                 end
               else
                 warn("No adapter found in config/database.yml, please configure it first")
               end
             else
               warn("Please configure your config/database.yml first")
             end
             group :development do
               gem "rdoc", ">= 2.4.2"
               gem "yard"
             end
             group :test do
               gem "shoulda", "~> 3.3.2"
               gem "mocha", ">= 0.14", :require => 'mocha/api'
               if RUBY_VERSION >= '1.9.3'
                 gem "capybara", "~> 2.1.0"
                 gem "selenium-webdriver"
               end
             end
             local_gemfile = File.join(File.dirname(__FILE__), "Gemfile.local")
             if File.exists?(local_gemfile)
               puts "Loading Gemfile.local ..." if $DEBUG # `ruby -d` or `bundle -v`
               instance_eval File.read(local_gemfile)
             end
             # Load plugins' Gemfiles
             Dir.glob File.expand_path("../plugins/*/Gemfile", __FILE__) do |file|
               puts "Loading #{file} ..." if $DEBUG # `ruby -d` or `bundle -v`
               #TODO: switch to "eval_gemfile file" when bundler >= 1.2.0 will be required (rails 4)
               instance_eval File.read(file), file
             end

lib/redmine.rb +2 0

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 'redmine/core_ext'
             begin
               require 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             require 'redmine/scm/base'
             require 'redmine/access_control'
             require 'redmine/access_keys'
             require 'redmine/activity'
             require 'redmine/activity/fetcher'
             require 'redmine/ciphering'
             require 'redmine/codeset_util'
             require 'redmine/field_format'
             require 'redmine/i18n'
             require 'redmine/menu_manager'
             require 'redmine/notifiable'
             require 'redmine/platform'
             require 'redmine/mime_type'
             require 'redmine/notifiable'
             require 'redmine/search'
             require 'redmine/syntax_highlighting'
             require 'redmine/thumbnail'
             require 'redmine/unified_diff'
             require 'redmine/utils'
             require 'redmine/version'
             require 'redmine/wiki_formatting'
             require 'redmine/default_data/loader'
             require 'redmine/helpers/calendar'
             require 'redmine/helpers/diff'
             require 'redmine/helpers/gantt'
             require 'redmine/helpers/time_report'
             require 'redmine/views/other_formats_builder'
             require 'redmine/views/labelled_form_builder'
             require 'redmine/views/builders'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/plugin'
             if RUBY_VERSION < '1.9'
               require 'fastercsv'
             else
               require 'csv'
               FCSV = CSV
             end
             Redmine::Scm::Base.add "Subversion"
             Redmine::Scm::Base.add "Darcs"
             Redmine::Scm::Base.add "Mercurial"
             Redmine::Scm::Base.add "Cvs"
             Redmine::Scm::Base.add "Bazaar"
             Redmine::Scm::Base.add "Git"
             Redmine::Scm::Base.add "Filesystem"
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show], :activities => [:index]}, :public => true, :read => true
               map.permission :search_project, {:search => :index}, :public => true, :read => true
               map.permission :add_project, {:projects => [:new, :create]}, :require => :loggedin
               map.permission :edit_project, {:projects => [:settings, :edit, :update]}, :require => :member
               map.permission :close_project, {:projects => [:close, :reopen]}, :require => :member, :read => true
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:index, :show, :create, :update, :destroy, :autocomplete]}, :require => :member
               map.permission :manage_versions, {:projects => :settings, :versions => [:new, :create, :edit, :update, :close_completed, :destroy]}, :require => :member
               map.permission :add_subprojects, {:projects => [:new, :create]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => :settings, :issue_categories => [:index, :show, :new, :create, :edit, :update, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:issues => [:index, :show],
                                               :auto_complete => [:issues],
                                               :context_menus => [:issues],
                                               :versions => [:index, :show, :status_by],
                                               :journals => [:index, :diff],
                                               :queries => :index,
                                               :reports => [:issue_report, :issue_report_details]},
                                               :read => true
                 map.permission :add_issues, {:issues => [:new, :create, :update_form], :attachments => :upload}
                 map.permission :edit_issues, {:issues => [:edit, :update, :bulk_edit, :bulk_update, :update_form], :journals => [:new], :attachments => :upload}
                 map.permission :manage_issue_relations, {:issue_relations => [:index, :show, :create, :destroy]}
                 map.permission :manage_subtasks, {}
                 map.permission :set_issues_private, {}
                 map.permission :set_own_issues_private, {}, :require => :loggedin
                 map.permission :add_issue_notes, {:issues => [:edit, :update, :update_form], :journals => [:new], :attachments => :upload}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :view_private_notes, {}, :read => true, :require => :member
                 map.permission :set_notes_private, {}, :require => :member
                 map.permission :move_issues, {:issues => [:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :loggedin
                 # Watchers
                 map.permission :view_issue_watchers, {}, :read => true
                 map.permission :add_issue_watchers, {:watchers => [:new, :create, :append, :autocomplete_for_user]}
                 map.permission :delete_issue_watchers, {:watchers => :destroy}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => [:new, :create]}, :require => :loggedin
                 map.permission :view_time_entries, {:timelog => [:index, :report, :show]}, :read => true
                 map.permission :edit_time_entries, {:timelog => [:edit, :update, :destroy, :bulk_edit, :bulk_update]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :update, :destroy,:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :manage_project_activities, {:project_enumerations => [:update, :destroy]}, :require => :member
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :create, :edit, :update, :destroy], :comments => [:destroy]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true, :read => true
                 map.permission :comment_news, {:comments => :create}
               end
               map.project_module :documents do |map|
                 map.permission :add_documents, {:documents => [:new, :create, :add_attachment]}, :require => :loggedin
                 map.permission :edit_documents, {:documents => [:edit, :update, :add_attachment]}, :require => :loggedin
                 map.permission :delete_documents, {:documents => [:destroy]}, :require => :loggedin
                 map.permission :view_documents, {:documents => [:index, :show, :download]}, :read => true
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:files => [:new, :create]}, :require => :loggedin
                 map.permission :view_files, {:files => :index, :versions => :download}, :read => true
               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, :destroy_version]}, :require => :member
                 map.permission :view_wiki_pages, {:wiki => [:index, :show, :special, :date_index]}, :read => true
                 map.permission :export_wiki_pages, {:wiki => [:export]}, :read => true
                 map.permission :view_wiki_edits, {:wiki => [:history, :diff, :annotate]}, :read => true
                 map.permission :edit_wiki_pages, :wiki => [:edit, :update, :preview, :add_attachment]
                 map.permission :delete_wiki_pages_attachments, {}
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:new, :create, :edit, :update, :committers, :destroy]}, :require => :member
                 map.permission :browse_repository, {:repositories => [:show, :browse, :entry, :raw, :annotate, :changes, :diff, :stats, :graph]}, :read => true
                 map.permission :view_changesets, {:repositories => [:show, :revisions, :revision]}, :read => true
                 map.permission :commit_access, {}
                 map.permission :manage_related_issues, {:repositories => [:add_related_issue, :remove_related_issue]}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true, :read => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote]}
                 map.permission :edit_messages, {:messages => :edit}, :require => :member
                 map.permission :edit_own_messages, {:messages => :edit}, :require => :loggedin
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
                 map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
               end
               map.project_module :calendar do |map|
                 map.permission :view_calendar, {:calendars => [:show, :update]}, :read => true
               end
               map.project_module :gantt do |map|
                 map.permission :view_gantt, {:gantts => [:show, :update]}, :read => true
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
               menu.push :register, :register_path, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :html => {:method => 'post'}, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :admin_menu do |menu|
               menu.push :projects, {:controller => 'admin', :action => 'projects'}, :caption => :label_project_plural
               menu.push :users, {:controller => 'users'}, :caption => :label_user_plural
               menu.push :groups, {:controller => 'groups'}, :caption => :label_group_plural
               menu.push :roles, {:controller => 'roles'}, :caption => :label_role_and_permissions
               menu.push :trackers, {:controller => 'trackers'}, :caption => :label_tracker_plural
               menu.push :issue_statuses, {:controller => 'issue_statuses'}, :caption => :label_issue_status_plural,
                         :html => {:class => 'issue_statuses'}
               menu.push :workflows, {:controller => 'workflows', :action => 'edit'}, :caption => :label_workflow
               menu.push :custom_fields, {:controller => 'custom_fields'},  :caption => :label_custom_field_plural,
                         :html => {:class => 'custom_fields'}
               menu.push :enumerations, {:controller => 'enumerations'}
               menu.push :settings, {:controller => 'settings'}
               menu.push :ldap_authentication, {:controller => 'auth_sources', :action => 'index'},
                         :html => {:class => 'server_authentication'}
               menu.push :plugins, {:controller => 'admin', :action => 'plugins'}, :last => true
               menu.push :info, {:controller => 'admin', :action => 'info'}, :caption => :label_information_plural, :last => true
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'activities', :action => 'index' }
               menu.push :roadmap, { :controller => 'versions', :action => 'index' }, :param => :project_id,
                           :if => Proc.new { |p| p.shared_versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new', :copy_from => nil }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
               menu.push :gantt, { :controller => 'gantts', :action => 'show' }, :param => :project_id, :caption => :label_gantt
               menu.push :calendar, { :controller => 'calendars', :action => 'show' }, :param => :project_id, :caption => :label_calendar
               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 => 'show', :id => nil }, :param => :project_id,
                           :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 => 'files', :action => 'index' }, :caption => :label_file_plural, :param => :project_id
               menu.push :repository, { :controller => 'repositories', :action => 'show', :repository_id => nil, :path => nil, :rev => nil },
                           :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
               activity.register :time_entries, :default => false
             end
             Redmine::Search.map do |search|
               search.register :issues
               search.register :news
               search.register :documents
               search.register :changesets
               search.register :wiki_pages
               search.register :messages
               search.register :projects
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile, Redmine::WikiFormatting::Textile::Formatter, Redmine::WikiFormatting::Textile::Helper
+              format.register :markdown, Redmine::WikiFormatting::Markdown::Formatter, Redmine::WikiFormatting::Markdown::Helper,
+                :label => 'Markdown (experimental)'
             end
             ActionView::Template.register_template_handler :rsb, Redmine::Views::ApiTemplateHandler

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