jro_apps/redmine Commit - r781:47e7ceacd72d

Better handling of external link style assignment....

Jean-Philippe Lang -

r781:47e7ceacd72d

parent child

Context file:

r781:47e7ceacd72d

Collapse all files

lib/redcloth.rb +3 -1

              #                                vim:ts=4:sw=4:
              # = RedCloth - Textile and Markdown Hybrid for Ruby
              #
              # Homepage::  http://whytheluckystiff.net/ruby/redcloth/
              # Author::    why the lucky stiff (http://whytheluckystiff.net/)
              # Copyright:: (cc) 2004 why the lucky stiff (and his puppet organizations.)
              # License::   BSD
              #
              # (see http://hobix.com/textile/ for a Textile Reference.)
              #
              # Based on (and also inspired by) both:
              #
              # PyTextile: http://diveintomark.org/projects/textile/textile.py.txt
              # Textism for PHP: http://www.textism.com/tools/textile/
              #
              #
              # = RedCloth
              #
              # RedCloth is a Ruby library for converting Textile and/or Markdown
              # into HTML.  You can use either format, intermingled or separately.
              # You can also extend RedCloth to honor your own custom text stylings.
              #
              # RedCloth users are encouraged to use Textile if they are generating
              # HTML and to use Markdown if others will be viewing the plain text.
              #
              # == What is Textile?
              #
              # Textile is a simple formatting style for text
              # documents, loosely based on some HTML conventions.
              #
              # == Sample Textile Text
              #
              #  h2. This is a title
              #
              #  h3. This is a subhead
              #
              #  This is a bit of paragraph.
              #
              #  bq. This is a blockquote.
              #
              # = Writing Textile
              #
              # A Textile document consists of paragraphs.  Paragraphs
              # can be specially formatted by adding a small instruction
              # to the beginning of the paragraph.
              #
              #  h[n].   Header of size [n].
              #  bq.     Blockquote.
              #  #       Numeric list.
              #  *       Bulleted list.
              #
              # == Quick Phrase Modifiers
              #
              # Quick phrase modifiers are also included, to allow formatting
              # of small portions of text within a paragraph.
              #
              #  \_emphasis\_
              #  \_\_italicized\_\_
              #  \*strong\*
              #  \*\*bold\*\*
              #  ??citation??
              #  -deleted text-
              #  +inserted text+
              #  ^superscript^
              #  ~subscript~
              #  @code@
              #  %(classname)span%
              #
              #  ==notextile== (leave text alone)
              #
              # == Links
              #
              # To make a hypertext link, put the link text in "quotation
              # marks" followed immediately by a colon and the URL of the link.
              #
              # Optional: text in (parentheses) following the link text,
              # but before the closing quotation mark, will become a Title
              # attribute for the link, visible as a tool tip when a cursor is above it.
              #
              # Example:
              #
              #  "This is a link (This is a title) ":http://www.textism.com
              #
              # Will become:
              #
              #  <a href="http://www.textism.com" title="This is a title">This is a link</a>
              #
              # == Images
              #
              # To insert an image, put the URL for the image inside exclamation marks.
              #
              # Optional: text that immediately follows the URL in (parentheses) will
              # be used as the Alt text for the image. Images on the web should always
              # have descriptive Alt text for the benefit of readers using non-graphical
              # browsers.
              #
              # Optional: place a colon followed by a URL immediately after the
              # closing ! to make the image into a link.
              #
              # Example:
              #
              #  !http://www.textism.com/common/textist.gif(Textist)!
              #
              # Will become:
              #
              #  <img src="http://www.textism.com/common/textist.gif" alt="Textist" />
              #
              # With a link:
              #
              #  !/common/textist.gif(Textist)!:http://textism.com
              #
              # Will become:
              #
              #  <a href="http://textism.com"><img src="/common/textist.gif" alt="Textist" /></a>
              #
              # == Defining Acronyms
              #
              # HTML allows authors to define acronyms via the tag. The definition appears as a
              # tool tip when a cursor hovers over the acronym. A crucial aid to clear writing,
              # this should be used at least once for each acronym in documents where they appear.
              #
              # To quickly define an acronym in Textile, place the full text in (parentheses)
              # immediately following the acronym.
              #
              # Example:
              #
              #  ACLU(American Civil Liberties Union)
              #
              # Will become:
              #
              #  <acronym title="American Civil Liberties Union">ACLU</acronym>
              #
              # == Adding Tables
              #
              # In Textile, simple tables can be added by seperating each column by
              # a pipe.
              #
              #     |a|simple|table|row|
              #     |And|Another|table|row|
              #
              # Attributes are defined by style definitions in parentheses.
              #
              #     table(border:1px solid black).
              #     (background:#ddd;color:red). |{}| | | |
              #
              # == Using RedCloth
              #
              # RedCloth is simply an extension of the String class, which can handle
              # Textile formatting.  Use it like a String and output HTML with its
              # RedCloth#to_html method.
              #
              #  doc = RedCloth.new "
              #
              #  h2. Test document
              #
              #  Just a simple test."
              #
              #  puts doc.to_html
              #
              # By default, RedCloth uses both Textile and Markdown formatting, with
              # Textile formatting taking precedence.  If you want to turn off Markdown
              # formatting, to boost speed and limit the processor:
              #
              #  class RedCloth::Textile.new( str )
              class RedCloth < String
                  VERSION = '3.0.4'
                  DEFAULT_RULES = [:textile, :markdown]
                  #
                  # Two accessor for setting security restrictions.
                  #
                  # This is a nice thing if you're using RedCloth for
                  # formatting in public places (e.g. Wikis) where you
                  # don't want users to abuse HTML for bad things.
                  #
                  # If +:filter_html+ is set, HTML which wasn't
                  # created by the Textile processor will be escaped.
                  #
                  # If +:filter_styles+ is set, it will also disable
                  # the style markup specifier. ('{color: red}')
                  #
                  attr_accessor :filter_html, :filter_styles
                  #
                  # Accessor for toggling hard breaks.
                  #
                  # If +:hard_breaks+ is set, single newlines will
                  # be converted to HTML break tags.  This is the
                  # default behavior for traditional RedCloth.
                  #
                  attr_accessor :hard_breaks
                  # Accessor for toggling lite mode.
                  #
                  # In lite mode, block-level rules are ignored.  This means
                  # that tables, paragraphs, lists, and such aren't available.
                  # Only the inline markup for bold, italics, entities and so on.
                  #
                  #   r = RedCloth.new( "And then? She *fell*!", [:lite_mode] )
                  #   r.to_html
                  #   #=> "And then? She <strong>fell</strong>!"
                  #
                  attr_accessor :lite_mode
                  #
                  # Accessor for toggling span caps.
                  #
                  # Textile places `span' tags around capitalized
                  # words by default, but this wreaks havoc on Wikis.
                  # If +:no_span_caps+ is set, this will be
                  # suppressed.
                  #
                  attr_accessor :no_span_caps
                  #
                  # Establishes the markup predence.  Available rules include:
                  #
                  # == Textile Rules
                  #
                  # The following textile rules can be set individually.  Or add the complete
                  # set of rules with the single :textile rule, which supplies the rule set in
                  # the following precedence:
                  #
                  # refs_textile::          Textile references (i.e. [hobix]http://hobix.com/)
                  # block_textile_table::   Textile table block structures
                  # block_textile_lists::   Textile list structures
                  # block_textile_prefix::  Textile blocks with prefixes (i.e. bq., h2., etc.)
                  # inline_textile_image::  Textile inline images
                  # inline_textile_link::   Textile inline links
                  # inline_textile_span::   Textile inline spans
                  # glyphs_textile:: Textile entities (such as em-dashes and smart quotes)
                  #
                  # == Markdown
                  #
                  # refs_markdown::         Markdown references (for example: [hobix]: http://hobix.com/)
                  # block_markdown_setext:: Markdown setext headers
                  # block_markdown_atx::    Markdown atx headers
                  # block_markdown_rule::   Markdown horizontal rules
                  # block_markdown_bq::     Markdown blockquotes
                  # block_markdown_lists::  Markdown lists
                  # inline_markdown_link::  Markdown links
                  attr_accessor :rules
                  # Returns a new RedCloth object, based on _string_ and
                  # enforcing all the included _restrictions_.
                  #
                  #   r = RedCloth.new( "h1. A <b>bold</b> man", [:filter_html] )
                  #   r.to_html
                  #     #=>"<h1>A &lt;b&gt;bold&lt;/b&gt; man</h1>"
                  #
                  def initialize( string, restrictions = [] )
                      restrictions.each { |r| method( "#{ r }=" ).call( true ) }
                      super( string )
                  end
                  #
                  # Generates HTML from the Textile contents.
                  #
                  #   r = RedCloth.new( "And then? She *fell*!" )
                  #   r.to_html( true )
                  #     #=>"And then? She <strong>fell</strong>!"
                  #
                  def to_html( *rules )
                      rules = DEFAULT_RULES if rules.empty?
                      # make our working copy
                      text = self.dup
                      @urlrefs = {}
                      @shelf = []
                      textile_rules = [:refs_textile, :block_textile_table, :block_textile_lists,
                                       :block_textile_prefix, :inline_textile_image, :inline_textile_link,
                                       :inline_textile_code, :inline_textile_span, :glyphs_textile]
                      markdown_rules = [:refs_markdown, :block_markdown_setext, :block_markdown_atx, :block_markdown_rule,
                                        :block_markdown_bq, :block_markdown_lists,
                                        :inline_markdown_reflink, :inline_markdown_link]
                      @rules = rules.collect do |rule|
                          case rule
                          when :markdown
                              markdown_rules
                          when :textile
                              textile_rules
                          else
                              rule
                          end
                      end.flatten
                      # standard clean up
                      incoming_entities text
                      clean_white_space text
                      # start processor
                      @pre_list = []
                      rip_offtags text
                      no_textile text
                      hard_break text
                      unless @lite_mode
                          refs text
                          blocks text
                      end
                      inline text
                      smooth_offtags text
                      retrieve text
                      text.gsub!( /<\/?notextile>/, '' )
                      text.gsub!( /x%x%/, '&#38;' )
                      clean_html text if filter_html
                      text.strip!
                      text
                  end
                  #######
                  private
                  #######
                  #
                  # Mapping of 8-bit ASCII codes to HTML numerical entity equivalents.
                  # (from PyTextile)
                  #
                  TEXTILE_TAGS =
                      [[128, 8364], [129, 0], [130, 8218], [131, 402], [132, 8222], [133, 8230],
                       [134, 8224], [135, 8225], [136, 710], [137, 8240], [138, 352], [139, 8249],
                       [140, 338], [141, 0], [142, 0], [143, 0], [144, 0], [145, 8216], [146, 8217],
                       [147, 8220], [148, 8221], [149, 8226], [150, 8211], [151, 8212], [152, 732],
                       [153, 8482], [154, 353], [155, 8250], [156, 339], [157, 0], [158, 0], [159, 376]].
                      collect! do |a, b|
                          [a.chr, ( b.zero? and "" or "&#{ b };" )]
                      end
                  #
                  # Regular expressions to convert to HTML.
                  #
                  A_HLGN = /(?:(?:<>|<|>|\=|[()]+)+)/
                  A_VLGN = /[\-^~]/
                  C_CLAS = '(?:\([^)]+\))'
                  C_LNGE = '(?:\[[^\]]+\])'
                  C_STYL = '(?:\{[^}]+\})'
                  S_CSPN = '(?:\\\\\d+)'
                  S_RSPN = '(?:/\d+)'
                  A = "(?:#{A_HLGN}?#{A_VLGN}?|#{A_VLGN}?#{A_HLGN}?)"
                  S = "(?:#{S_CSPN}?#{S_RSPN}|#{S_RSPN}?#{S_CSPN}?)"
                  C = "(?:#{C_CLAS}?#{C_STYL}?#{C_LNGE}?|#{C_STYL}?#{C_LNGE}?#{C_CLAS}?|#{C_LNGE}?#{C_STYL}?#{C_CLAS}?)"
                  # PUNCT = Regexp::quote( '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~' )
                  PUNCT = Regexp::quote( '!"#$%&\'*+,-./:;=?@\\^_`|~' )
                  PUNCT_NOQ = Regexp::quote( '!"#$&\',./:;=?@\\`|' )
                  PUNCT_Q = Regexp::quote( '*-_+^~%' )
                  HYPERLINK = '(\S+?)([^\w\s/;=\?]*?)(?=\s|<|$)'
                  # Text markup tags, don't conflict with block tags
                  SIMPLE_HTML_TAGS = [
                      'tt', 'b', 'i', 'big', 'small', 'em', 'strong', 'dfn', 'code',
                      'samp', 'kbd', 'var', 'cite', 'abbr', 'acronym', 'a', 'img', 'br',
                      'br', 'map', 'q', 'sub', 'sup', 'span', 'bdo'
                  ]
                  QTAGS = [
                      ['**', 'b'],
                      ['*', 'strong'],
                      ['??', 'cite', :limit],
                      ['-', 'del', :limit],
                      ['__', 'i'],
                      ['_', 'em', :limit],
                      ['%', 'span', :limit],
                      ['+', 'ins', :limit],
                      ['^', 'sup'],
                      ['~', 'sub']
                  ]
                  QTAGS.collect! do |rc, ht, rtype|
                      rcq = Regexp::quote rc
                      re =
                          case rtype
                          when :limit
                              /(\W)
                              (#{rcq})
                              (#{C})
                              (?::(\S+?))?
                              (\S.*?\S|\S)
                              #{rcq}
                              (?=\W)/x
                          else
                              /(#{rcq})
                              (#{C})
                              (?::(\S+))?
                              (\S.*?\S|\S)
                              #{rcq}/xm
                          end
                      [rc, ht, re, rtype]
                  end
                  # Elements to handle
                  GLYPHS = [
                  #   [ /([^\s\[{(>])?\'([dmst]\b|ll\b|ve\b|\s|:|$)/, '\1&#8217;\2' ], # single closing
                      [ /([^\s\[{(>#{PUNCT_Q}][#{PUNCT_Q}]*)\'/, '\1&#8217;' ], # single closing
                      [ /\'(?=[#{PUNCT_Q}]*(s\b|[\s#{PUNCT_NOQ}]))/, '&#8217;' ], # single closing
                      [ /\'/, '&#8216;' ], # single opening
                      [ /</, '&lt;' ], # less-than
                      [ />/, '&gt;' ], # greater-than
                  #   [ /([^\s\[{(])?"(\s|:|$)/, '\1&#8221;\2' ], # double closing
                      [ /([^\s\[{(>#{PUNCT_Q}][#{PUNCT_Q}]*)"/, '\1&#8221;' ], # double closing
                      [ /"(?=[#{PUNCT_Q}]*[\s#{PUNCT_NOQ}])/, '&#8221;' ], # double closing
                      [ /"/, '&#8220;' ], # double opening
                      [ /\b( )?\.{3}/, '\1&#8230;' ], # ellipsis
                      [ /\b([A-Z][A-Z0-9]{2,})\b(?:[(]([^)]*)[)])/, '<acronym title="\2">\1</acronym>' ], # 3+ uppercase acronym
                      [ /(^|[^"][>\s])([A-Z][A-Z0-9 ]+[A-Z0-9])([^<A-Za-z0-9]|$)/, '\1<span class="caps">\2</span>\3', :no_span_caps ], # 3+ uppercase caps
                      [ /(\.\s)?\s?--\s?/, '\1&#8212;' ], # em dash
                      [ /\s->\s/, ' &rarr; ' ], # right arrow
                      [ /\s-\s/, ' &#8211; ' ], # en dash
                      [ /(\d+) ?x ?(\d+)/, '\1&#215;\2' ], # dimension sign
                      [ /\b ?[(\[]TM[\])]/i, '&#8482;' ], # trademark
                      [ /\b ?[(\[]R[\])]/i, '&#174;' ], # registered
                      [ /\b ?[(\[]C[\])]/i, '&#169;' ] # copyright
                  ]
                  H_ALGN_VALS = {
                      '<' => 'left',
                      '=' => 'center',
                      '>' => 'right',
                      '<>' => 'justify'
                  }
                  V_ALGN_VALS = {
                      '^' => 'top',
                      '-' => 'middle',
                      '~' => 'bottom'
                  }
                  #
                  # Flexible HTML escaping
                  #
                  def htmlesc( str, mode )
                      str.gsub!( '&', '&amp;' )
                      str.gsub!( '"', '&quot;' ) if mode != :NoQuotes
                      str.gsub!( "'", '&#039;' ) if mode == :Quotes
                      str.gsub!( '<', '&lt;')
                      str.gsub!( '>', '&gt;')
                  end
                  # Search and replace for Textile glyphs (quotes, dashes, other symbols)
                  def pgl( text )
                      GLYPHS.each do |re, resub, tog|
                          next if tog and method( tog ).call
                          text.gsub! re, resub
                      end
                  end
                  # Parses Textile attribute lists and builds an HTML attribute string
                  def pba( text_in, element = "" )
                      return '' unless text_in
                      style = []
                      text = text_in.dup
                      if element == 'td'
                          colspan = $1 if text =~ /\\(\d+)/
                          rowspan = $1 if text =~ /\/(\d+)/
                          style << "vertical-align:#{ v_align( $& ) };" if text =~ A_VLGN
                      end
                      style << "#{ $1 };" if not filter_styles and
                          text.sub!( /\{([^}]*)\}/, '' )
                      lang = $1 if
                          text.sub!( /\[([^)]+?)\]/, '' )
                      cls = $1 if
                          text.sub!( /\(([^()]+?)\)/, '' )
                      style << "padding-left:#{ $1.length }em;" if
                          text.sub!( /([(]+)/, '' )
                      style << "padding-right:#{ $1.length }em;" if text.sub!( /([)]+)/, '' )
                      style << "text-align:#{ h_align( $& ) };" if text =~ A_HLGN
                      cls, id = $1, $2 if cls =~ /^(.*?)#(.*)$/
                      atts = ''
                      atts << " style=\"#{ style.join }\"" unless style.empty?
                      atts << " class=\"#{ cls }\"" unless cls.to_s.empty?
                      atts << " lang=\"#{ lang }\"" if lang
                      atts << " id=\"#{ id }\"" if id
                      atts << " colspan=\"#{ colspan }\"" if colspan
                      atts << " rowspan=\"#{ rowspan }\"" if rowspan
                      atts
                  end
                  TABLE_RE = /^(?:table(_?#{S}#{A}#{C})\. ?\n)?^(#{A}#{C}\.? ?\|.*?\|)(\n\n|\Z)/m
                  # Parses a Textile table block, building HTML from the result.
                  def block_textile_table( text )
                      text.gsub!( TABLE_RE ) do |matches|
                          tatts, fullrow = $~[1..2]
                          tatts = pba( tatts, 'table' )
                          tatts = shelve( tatts ) if tatts
                          rows = []
                          fullrow.
                          split( /\|$/m ).
                          delete_if { |x| x.empty? }.
                          each do |row|
                              ratts, row = pba( $1, 'tr' ), $2 if row =~ /^(#{A}#{C}\. )(.*)/m
                              cells = []
                              row.split( '|' ).each do |cell|
                                  ctyp = 'd'
                                  ctyp = 'h' if cell =~ /^_/
                                  catts = ''
                                  catts, cell = pba( $1, 'td' ), $2 if cell =~ /^(_?#{S}#{A}#{C}\. ?)(.*)/
                                  unless cell.strip.empty?
                                      catts = shelve( catts ) if catts
                                      cells << "\t\t\t<t#{ ctyp }#{ catts }>#{ cell }</t#{ ctyp }>"
                                  end
                              end
                              ratts = shelve( ratts ) if ratts
                              rows << "\t\t<tr#{ ratts }>\n#{ cells.join( "\n" ) }\n\t\t</tr>"
                          end
                          "\t<table#{ tatts }>\n#{ rows.join( "\n" ) }\n\t</table>\n\n"
                      end
                  end
                  LISTS_RE = /^([#*]+?#{C} .*?)$(?![^#*])/m
                  LISTS_CONTENT_RE = /^([#*]+)(#{A}#{C}) (.*)$/m
                  # Parses Textile lists and generates HTML
                  def block_textile_lists( text )
                      text.gsub!( LISTS_RE ) do |match|
                          lines = match.split( /\n/ )
                          last_line = -1
                          depth = []
                          lines.each_with_index do |line, line_id|
                              if line =~ LISTS_CONTENT_RE
                                  tl,atts,content = $~[1..3]
                                  if depth.last
                                      if depth.last.length > tl.length
                                          (depth.length - 1).downto(0) do |i|
                                              break if depth[i].length == tl.length
                                              lines[line_id - 1] << "</li>\n\t</#{ lT( depth[i] ) }l>\n\t"
                                              depth.pop
                                          end
                                      end
                                      if depth.last and depth.last.length == tl.length
                                          lines[line_id - 1] << '</li>'
                                      end
                                  end
                                  unless depth.last == tl
                                      depth << tl
                                      atts = pba( atts )
                                      atts = shelve( atts ) if atts
                                      lines[line_id] = "\t<#{ lT(tl) }l#{ atts }>\n\t<li>#{ content }"
                                  else
                                      lines[line_id] = "\t\t<li>#{ content }"
                                  end
                                  last_line = line_id
                              else
                                  last_line = line_id
                              end
                              if line_id - last_line > 1 or line_id == lines.length - 1
                                  depth.delete_if do |v|
                                      lines[last_line] << "</li>\n\t</#{ lT( v ) }l>"
                                  end
                              end
                          end
                          lines.join( "\n" )
                      end
                  end
                  CODE_RE = /(\W)
                      @
                      (?:\|(\w+?)\|)?
                      (.+?)
                      @
                      (?=\W)/x
                  def inline_textile_code( text )
                      text.gsub!( CODE_RE ) do |m|
                          before,lang,code,after = $~[1..4]
                          lang = " lang=\"#{ lang }\"" if lang
                          rip_offtags( "#{ before }<code#{ lang }>#{ code }</code>#{ after }" )
                      end
                  end
                  def lT( text )
                      text =~ /\#$/ ? 'o' : 'u'
                  end
                  def hard_break( text )
                      text.gsub!( /(.)\n(?!\Z| *([#*=]+(\s|$)|[{|]))/, "\\1<br />" ) if hard_breaks
                  end
                  BLOCKS_GROUP_RE = /\n{2,}(?! )/m
                  def blocks( text, deep_code = false )
                      text.replace( text.split( BLOCKS_GROUP_RE ).collect do |blk|
                          plain = blk !~ /\A[#*> ]/
                          # skip blocks that are complex HTML
                          if blk =~ /^<\/?(\w+).*>/ and not SIMPLE_HTML_TAGS.include? $1
                              blk
                          else
                              # search for indentation levels
                              blk.strip!
                              if blk.empty?
                                  blk
                              else
                                  code_blk = nil
                                  blk.gsub!( /((?:\n(?:\n^ +[^\n]*)+)+)/m ) do |iblk|
                                      flush_left iblk
                                      blocks iblk, plain
                                      iblk.gsub( /^(\S)/, "\t\\1" )
                                      if plain
                                          code_blk = iblk; ""
                                      else
                                          iblk
                                      end
                                  end
                                  block_applied = 0
                                  @rules.each do |rule_name|
                                      block_applied += 1 if ( rule_name.to_s.match /^block_/ and method( rule_name ).call( blk ) )
                                  end
                                  if block_applied.zero?
                                      if deep_code
                                          blk = "\t<pre><code>#{ blk }</code></pre>"
                                      else
                                          blk = "\t<p>#{ blk }</p>"
                                      end
                                  end
                                  # hard_break blk
                                  blk + "\n#{ code_blk }"
                              end
                          end
                      end.join( "\n\n" ) )
                  end
                  def textile_bq( tag, atts, cite, content )
                      cite, cite_title = check_refs( cite )
                      cite = " cite=\"#{ cite }\"" if cite
                      atts = shelve( atts ) if atts
                      "\t<blockquote#{ cite }>\n\t\t<p#{ atts }>#{ content }</p>\n\t</blockquote>"
                  end
                  def textile_p( tag, atts, cite, content )
                      atts = shelve( atts ) if atts
                      "\t<#{ tag }#{ atts }>#{ content }</#{ tag }>"
                  end
                  alias textile_h1 textile_p
                  alias textile_h2 textile_p
                  alias textile_h3 textile_p
                  alias textile_h4 textile_p
                  alias textile_h5 textile_p
                  alias textile_h6 textile_p
                  def textile_fn_( tag, num, atts, cite, content )
                      atts << " id=\"fn#{ num }\""
                      content = "<sup>#{ num }</sup> #{ content }"
                      atts = shelve( atts ) if atts
                      "\t<p#{ atts }>#{ content }</p>"
                  end
                  BLOCK_RE = /^(([a-z]+)(\d*))(#{A}#{C})\.(?::(\S+))? (.*)$/m
                  def block_textile_prefix( text )
                      if text =~ BLOCK_RE
                          tag,tagpre,num,atts,cite,content = $~[1..6]
                          atts = pba( atts )
                          # pass to prefix handler
                          if respond_to? "textile_#{ tag }", true
                              text.gsub!( $&, method( "textile_#{ tag }" ).call( tag, atts, cite, content ) )
                          elsif respond_to? "textile_#{ tagpre }_", true
                              text.gsub!( $&, method( "textile_#{ tagpre }_" ).call( tagpre, num, atts, cite, content ) )
                          end
                      end
                  end
                  SETEXT_RE = /\A(.+?)\n([=-])[=-]* *$/m
                  def block_markdown_setext( text )
                      if text =~ SETEXT_RE
                          tag = if $2 == "="; "h1"; else; "h2"; end
                          blk, cont = "<#{ tag }>#{ $1 }</#{ tag }>", $'
                          blocks cont
                          text.replace( blk + cont )
                      end
                  end
                  ATX_RE = /\A(\#{1,6})  # $1 = string of #'s
                            [ ]*
                            (.+?)       # $2 = Header text
                            [ ]*
                            \#*         # optional closing #'s (not counted)
                            $/x
                  def block_markdown_atx( text )
                      if text =~ ATX_RE
                          tag = "h#{ $1.length }"
                          blk, cont = "<#{ tag }>#{ $2 }</#{ tag }>\n\n", $'
                          blocks cont
                          text.replace( blk + cont )
                      end
                  end
                  MARKDOWN_BQ_RE = /\A(^ *> ?.+$(.+\n)*\n*)+/m
                  def block_markdown_bq( text )
                      text.gsub!( MARKDOWN_BQ_RE ) do |blk|
                          blk.gsub!( /^ *> ?/, '' )
                          flush_left blk
                          blocks blk
                          blk.gsub!( /^(\S)/, "\t\\1" )
                          "<blockquote>\n#{ blk }\n</blockquote>\n\n"
                      end
                  end
                  MARKDOWN_RULE_RE = /^(#{
                      ['*', '-', '_'].collect { |ch| '( ?' + Regexp::quote( ch ) + ' ?){3,}' }.join( '|' )
                  })$/
                  def block_markdown_rule( text )
                      text.gsub!( MARKDOWN_RULE_RE ) do |blk|
                          "<hr />"
                      end
                  end
                  # XXX TODO XXX
                  def block_markdown_lists( text )
                  end
                  def inline_textile_span( text )
                      QTAGS.each do |qtag_rc, ht, qtag_re, rtype|
                          text.gsub!( qtag_re ) do |m|
                              case rtype
                              when :limit
                                  sta,qtag,atts,cite,content = $~[1..5]
                              else
                                  qtag,atts,cite,content = $~[1..4]
                                  sta = ''
                              end
                              atts = pba( atts )
                              atts << " cite=\"#{ cite }\"" if cite
                              atts = shelve( atts ) if atts
                              "#{ sta }<#{ ht }#{ atts }>#{ content }</#{ ht }>"
                          end
                      end
                  end
                  LINK_RE = /
                          ([\s\[{(]|[#{PUNCT}])?     # $pre
                          "                          # start
                          (#{C})                     # $atts
                          ([^"]+?)                   # $text
                          \s?
                          (?:\(([^)]+?)\)(?="))?     # $title
                          ":
                          (\S+?)                     # $url
                          (\/)?                      # $slash
                          ([^\w\/;]*?)               # $post
                          (?=<|\s|$)
                      /x
                  def inline_textile_link( text )
                      text.gsub!( LINK_RE ) do |m|
                          pre,atts,text,title,url,slash,post = $~[1..7]
                          url, url_title = check_refs( url )
                          title ||= url_title
                          atts = pba( atts )
                          atts = " href=\"#{ url }#{ slash }\"#{ atts }"
                          atts << " title=\"#{ title }\"" if title
                          atts = shelve( atts ) if atts
-                         "#{ pre }<a#{ atts }>#{ text }</a>#{ post }"
+                         external = (url =~ /^http:\/\//) ? ' class="external"' : ''
+                         "#{ pre }<a#{ atts }#{ external }>#{ text }</a>#{ post }"
                      end
                  end
                  MARKDOWN_REFLINK_RE = /
                          \[([^\[\]]+)\]      # $text
                          [ ]?                # opt. space
                          (?:\n[ ]*)?         # one optional newline followed by spaces
                          \[(.*?)\]           # $id
                      /x
                  def inline_markdown_reflink( text )
                      text.gsub!( MARKDOWN_REFLINK_RE ) do |m|
                          text, id = $~[1..2]
                          if id.empty?
                              url, title = check_refs( text )
                          else
                              url, title = check_refs( id )
                          end
                          atts = " href=\"#{ url }\""
                          atts << " title=\"#{ title }\"" if title
                          atts = shelve( atts )
                          "<a#{ atts }>#{ text }</a>"
                      end
                  end
                  MARKDOWN_LINK_RE = /
                          \[([^\[\]]+)\]      # $text
                          \(                  # open paren
                          [ \t]*              # opt space
                          <?(.+?)>?           # $href
                          [ \t]*              # opt space
                          (?:                 # whole title
                          (['"])              # $quote
                          (.*?)               # $title
                          \3                  # matching quote
                          )?                  # title is optional
                          \)
                      /x
                  def inline_markdown_link( text )
                      text.gsub!( MARKDOWN_LINK_RE ) do |m|
                          text, url, quote, title = $~[1..4]
                          atts = " href=\"#{ url }\""
                          atts << " title=\"#{ title }\"" if title
                          atts = shelve( atts )
                          "<a#{ atts }>#{ text }</a>"
                      end
                  end
                  TEXTILE_REFS_RE =  /(^ *)\[([^\[\n]+?)\](#{HYPERLINK})(?=\s|$)/
                  MARKDOWN_REFS_RE = /(^ *)\[([^\n]+?)\]:\s+<?(#{HYPERLINK})>?(?:\s+"((?:[^"]|\\")+)")?(?=\s|$)/m
                  def refs( text )
                      @rules.each do |rule_name|
                          method( rule_name ).call( text ) if rule_name.to_s.match /^refs_/
                      end
                  end
                  def refs_textile( text )
                      text.gsub!( TEXTILE_REFS_RE ) do |m|
                          flag, url = $~[2..3]
                          @urlrefs[flag.downcase] = [url, nil]
                          nil
                      end
                  end
                  def refs_markdown( text )
                      text.gsub!( MARKDOWN_REFS_RE ) do |m|
                          flag, url = $~[2..3]
                          title = $~[6]
                          @urlrefs[flag.downcase] = [url, title]
                          nil
                      end
                  end
                  def check_refs( text )
                      ret = @urlrefs[text.downcase] if text
                      ret || [text, nil]
                  end
                  IMAGE_RE = /
                          (<p>|.|^)            # start of line?
                          \!                   # opening
                          (\<|\=|\>)?          # optional alignment atts
                          (#{C})               # optional style,class atts
                          (?:\. )?             # optional dot-space
                          ([^\s(!]+?)          # presume this is the src
                          \s?                  # optional space
                          (?:\(((?:[^\(\)]|\([^\)]+\))+?)\))?   # optional title
                          \!                   # closing
                          (?::#{ HYPERLINK })? # optional href
                      /x
                  def inline_textile_image( text )
                      text.gsub!( IMAGE_RE )  do |m|
                          stln,algn,atts,url,title,href,href_a1,href_a2 = $~[1..8]
                          atts = pba( atts )
                          atts = " src=\"#{ url }\"#{ atts }"
                          atts << " title=\"#{ title }\"" if title
                          atts << " alt=\"#{ title }\""
                          # size = @getimagesize($url);
                          # if($size) $atts.= " $size[3]";
                          href, alt_title = check_refs( href ) if href
                          url, url_title = check_refs( url )
                          out = ''
                          out << "<a#{ shelve( " href=\"#{ href }\"" ) }>" if href
                          out << "<img#{ shelve( atts ) } />"
                          out << "</a>#{ href_a1 }#{ href_a2 }" if href
                          if algn
                              algn = h_align( algn )
                              if stln == "<p>"
                                  out = "<p style=\"float:#{ algn }\">#{ out }"
                              else
                                  out = "#{ stln }<div style=\"float:#{ algn }\">#{ out }</div>"
                              end
                          else
                              out = stln + out
                          end
                          out
                      end
                  end
                  def shelve( val )
                      @shelf << val
                      " :redsh##{ @shelf.length }:"
                  end
                  def retrieve( text )
                      @shelf.each_with_index do |r, i|
                          text.gsub!( " :redsh##{ i + 1 }:", r )
                      end
                  end
                  def incoming_entities( text )
                      ## turn any incoming ampersands into a dummy character for now.
                      ## This uses a negative lookahead for alphanumerics followed by a semicolon,
                      ## implying an incoming html entity, to be skipped
                      text.gsub!( /&(?![#a-z0-9]+;)/i, "x%x%" )
                  end
                  def no_textile( text )
                      text.gsub!( /(^|\s)==([^=]+.*?)==(\s|$)?/,
                          '\1<notextile>\2</notextile>\3' )
                      text.gsub!( /^ *==([^=]+.*?)==/m,
                          '\1<notextile>\2</notextile>\3' )
                  end
                  def clean_white_space( text )
                      # normalize line breaks
                      text.gsub!( /\r\n/, "\n" )
                      text.gsub!( /\r/, "\n" )
                      text.gsub!( /\t/, '    ' )
                      text.gsub!( /^ +$/, '' )
                      text.gsub!( /\n{3,}/, "\n\n" )
                      text.gsub!( /"$/, "\" " )
                      # if entire document is indented, flush
                      # to the left side
                      flush_left text
                  end
                  def flush_left( text )
                      indt = 0
                      if text =~ /^ /
                          while text !~ /^ {#{indt}}\S/
                              indt += 1
                          end unless text.empty?
                          if indt.nonzero?
                              text.gsub!( /^ {#{indt}}/, '' )
                          end
                      end
                  end
                  def footnote_ref( text )
                      text.gsub!( /\b\[([0-9]+?)\](\s)?/,
                          '<sup><a href="#fn\1">\1</a></sup>\2' )
                  end
                  OFFTAGS = /(code|pre|kbd|notextile)/
                  OFFTAG_MATCH = /(?:(<\/#{ OFFTAGS }>)|(<#{ OFFTAGS }[^>]*>))(.*?)(?=<\/?#{ OFFTAGS }|\Z)/mi
                  OFFTAG_OPEN = /<#{ OFFTAGS }/
                  OFFTAG_CLOSE = /<\/?#{ OFFTAGS }/
                  HASTAG_MATCH = /(<\/?\w[^\n]*?>)/m
                  ALLTAG_MATCH = /(<\/?\w[^\n]*?>)|.*?(?=<\/?\w[^\n]*?>|$)/m
                  def glyphs_textile( text, level = 0 )
                      if text !~ HASTAG_MATCH
                          pgl text
                          footnote_ref text
                      else
                          codepre = 0
                          text.gsub!( ALLTAG_MATCH ) do |line|
                              ## matches are off if we're between <code>, <pre> etc.
                              if $1
                                  if line =~ OFFTAG_OPEN
                                      codepre += 1
                                  elsif line =~ OFFTAG_CLOSE
                                      codepre -= 1
                                      codepre = 0 if codepre < 0
                                  end
                              elsif codepre.zero?
                                  glyphs_textile( line, level + 1 )
                              else
                                  htmlesc( line, :NoQuotes )
                              end
                              # p [level, codepre, line]
                              line
                          end
                      end
                  end
                  def rip_offtags( text )
                      if text =~ /<.*>/
                          ## strip and encode <pre> content
                          codepre, used_offtags = 0, {}
                          text.gsub!( OFFTAG_MATCH ) do |line|
                              if $3
                                  offtag, aftertag = $4, $5
                                  codepre += 1
                                  used_offtags[offtag] = true
                                  if codepre - used_offtags.length > 0
                                      htmlesc( line, :NoQuotes ) unless used_offtags['notextile']
                                      @pre_list.last << line
                                      line = ""
                                  else
                                      htmlesc( aftertag, :NoQuotes ) if aftertag and not used_offtags['notextile']
                                      line = "<redpre##{ @pre_list.length }>"
                                      @pre_list << "#{ $3 }#{ aftertag }"
                                  end
                              elsif $1 and codepre > 0
                                  if codepre - used_offtags.length > 0
                                      htmlesc( line, :NoQuotes ) unless used_offtags['notextile']
                                      @pre_list.last << line
                                      line = ""
                                  end
                                  codepre -= 1 unless codepre.zero?
                                  used_offtags = {} if codepre.zero?
                              end
                              line
                          end
                      end
                      text
                  end
                  def smooth_offtags( text )
                      unless @pre_list.empty?
                          ## replace <pre> content
                          text.gsub!( /<redpre#(\d+)>/ ) { @pre_list[$1.to_i] }
                      end
                  end
                  def inline( text )
                      [/^inline_/, /^glyphs_/].each do |meth_re|
                          @rules.each do |rule_name|
                              method( rule_name ).call( text ) if rule_name.to_s.match( meth_re )
                          end
                      end
                  end
                  def h_align( text )
                      H_ALGN_VALS[text]
                  end
                  def v_align( text )
                      V_ALGN_VALS[text]
                  end
                  def textile_popup_help( name, windowW, windowH )
                      ' <a target="_blank" href="http://hobix.com/textile/#' + helpvar + '" onclick="window.open(this.href, \'popupwindow\', \'width=' + windowW + ',height=' + windowH + ',scrollbars,resizable\'); return false;">' + name + '</a><br />'
                  end
                  # HTML cleansing stuff
                  BASIC_TAGS = {
                      'a' => ['href', 'title'],
                      'img' => ['src', 'alt', 'title'],
                      'br' => [],
                      'i' => nil,
                      'u' => nil,
                      'b' => nil,
                      'pre' => nil,
                      'kbd' => nil,
                      'code' => ['lang'],
                      'cite' => nil,
                      'strong' => nil,
                      'em' => nil,
                      'ins' => nil,
                      'sup' => nil,
                      'sub' => nil,
                      'del' => nil,
                      'table' => nil,
                      'tr' => nil,
                      'td' => ['colspan', 'rowspan'],
                      'th' => nil,
                      'ol' => nil,
                      'ul' => nil,
                      'li' => nil,
                      'p' => nil,
                      'h1' => nil,
                      'h2' => nil,
                      'h3' => nil,
                      'h4' => nil,
                      'h5' => nil,
                      'h6' => nil,
                      'blockquote' => ['cite']
                  }
                  def clean_html( text, tags = BASIC_TAGS )
                      text.gsub!( /<!\[CDATA\[/, '' )
                      text.gsub!( /<(\/*)(\w+)([^>]*)>/ ) do
                          raw = $~
                          tag = raw[2].downcase
                          if tags.has_key? tag
                              pcs = [tag]
                              tags[tag].each do |prop|
                                  ['"', "'", ''].each do |q|
                                      q2 = ( q != '' ? q : '\s' )
                                      if raw[3] =~ /#{prop}\s*=\s*#{q}([^#{q2}]+)#{q}/i
                                          attrv = $1
                                          next if prop == 'src' and attrv =~ %r{^(?!http)\w+:}
                                          pcs << "#{prop}=\"#{$1.gsub('"', '\\"')}\""
                                          break
                                      end
                                  end
                              end if tags[tag]
                              "<#{raw[1]}#{pcs.join " "}>"
                          else
                              " "
                          end
                      end
                  end
              end

lib/redmine/wiki_formatting.rb +1 -1

              require 'redcloth'
              require 'coderay'
              require 'pp'
              module Redmine
                module WikiFormatting
                private
                  class TextileFormatter < RedCloth
                    RULES = [:inline_auto_link, :inline_auto_mailto, :textile, :inline_toc]
                    def initialize(*args)
                      super
                      self.hard_breaks=true
                      self.no_span_caps=true
                    end
                    def to_html
                      @toc = []
                      super(*RULES).to_s
                    end
                  private
                    # Patch for RedCloth.  Fixed in RedCloth r128 but _why hasn't released it yet.
                    # <a href="http://code.whytheluckystiff.net/redcloth/changeset/128">http://code.whytheluckystiff.net/redcloth/changeset/128</a>
                    def hard_break( text )
                      text.gsub!( /(.)\n(?!\n|\Z| *([#*=]+(\s|$)|[{|]))/, "\\1<br />" ) if hard_breaks
                    end
                    # Patch to add code highlighting support to RedCloth
                    def smooth_offtags( text )
                      unless @pre_list.empty?
                        ## replace <pre> content
                        text.gsub!(/<redpre#(\d+)>/) do
                          content = @pre_list[$1.to_i]
                          if content.match(/<code\s+class="(\w+)">\s?(.+)/m)
                            content = "<code class=\"#{$1} CodeRay\">" +
                              CodeRay.scan($2, $1).html(:escape => false, :line_numbers => :inline)
                          end
                          content
                        end
                      end
                    end
                    # Patch to add 'table of content' support to RedCloth
                    def textile_p_withtoc(tag, atts, cite, content)
                      if tag =~ /^h(\d)$/
                        @toc << [$1.to_i, content]
                      end
                      content = "<a name=\"#{@toc.length}\" class=\"wiki-page\"></a>" + content
                      textile_p(tag, atts, cite, content)
                    end
                    alias :textile_h1 :textile_p_withtoc
                    alias :textile_h2 :textile_p_withtoc
                    alias :textile_h3 :textile_p_withtoc
                    def inline_toc(text)
                      text.gsub!(/<p>\{\{([<>]?)toc\}\}<\/p>/i) do
                        div_class = 'toc'
                        div_class << ' right' if $1 == '>'
                        div_class << ' left' if $1 == '<'
                        out = "<div class=\"#{div_class}\">"
                        @toc.each_with_index do |heading, index|
                          # remove wiki links from the item
                          toc_item = heading.last.gsub(/(\[\[|\]\])/, '')
                          out << "<a href=\"##{index+1}\" class=\"heading#{heading.first}\">#{toc_item}</a>"
                        end
                        out << '</div>'
                        out
                      end
                    end
                    AUTO_LINK_RE = %r{
                                      (                          # leading text
                                        <\w+.*?>|                # leading HTML tag, or
                                        [^=<>!:'"/]|             # leading punctuation, or
                                        ^                        # beginning of line
                                      )
                                      (
                                        (?:https?://)|           # protocol spec, or
                                        (?:www\.)                # www.*
                                      )
                                      (
                                        (\S+?)                   # url
                                        (\/)?                    # slash
                                      )
                                      ([^\w\=\/;]*?)               # post
                                      (?=<|\s|$)
                                     }x unless const_defined?(:AUTO_LINK_RE)
                    # Turns all urls into clickable links (code from Rails).
                    def inline_auto_link(text)
                      text.gsub!(AUTO_LINK_RE) do
                        all, leading, proto, url, post = $&, $1, $2, $3, $6
                        if leading =~ /<a\s/i || leading =~ /![<>=]?/
                          # don't replace URL's that are already linked
                          # and URL's prefixed with ! !> !< != (textile images)
                          all
                        else
-                         %(#{leading}<a href="#{proto=="www."?"http://www.":proto}#{url}">#{proto + url}</a>#{post})
+                         %(#{leading}<a class="external" href="#{proto=="www."?"http://www.":proto}#{url}">#{proto + url}</a>#{post})
                        end
                      end
                    end
                    # Turns all email addresses into clickable links (code from Rails).
                    def inline_auto_mailto(text)
                      text.gsub!(/([\w\.!#\$%\-+.]+@[A-Za-z0-9\-]+(\.[A-Za-z0-9\-]+)+)/) do
                        text = $1
                        %{<a href="mailto:#{$1}" class="email">#{text}</a>}
                      end
                    end
                  end
                public
                  def self.to_html(text, options = {})
                    TextileFormatter.new(text).to_html
                  end
                end
              end

public/stylesheets/application.css +1 -6

              body { font-family: Verdana, sans-serif; font-size: 12px; color:#484848; margin: 0; padding: 0; min-width: 900px; }
              h1, h2, h3, h4 { font-family: "Trebuchet MS", Verdana, sans-serif;}
              h1 {margin:0; padding:0; font-size: 24px;}
              h2, .wiki h1 {font-size: 20px;padding: 2px 10px 1px 0px;margin: 0 0 10px 0; border-bottom: 1px solid #bbbbbb; color: #444;}
              h3, .wiki h2 {font-size: 16px;padding: 2px 10px 1px 0px;margin: 0 0 10px 0; border-bottom: 1px solid #bbbbbb; color: #444;}
              h4, .wiki h3 {font-size: 12px;padding: 2px 10px 1px 0px;margin-bottom: 5px; border-bottom: 1px dotted #bbbbbb; color: #444;}
              /***** Layout *****/
              #top-menu {background: #2C4056;color: #fff;height:1.5em; padding: 2px 6px 0px 6px;}
              #top-menu a {color: #fff; padding-right: 4px;}
              #account {float:right;}
              #header {height:5.3em;margin:0;background-color:#507AAA;color:#f8f8f8; padding: 4px 8px 0px 6px;}
              #header a {color:#f8f8f8;}
              #quick-search {float:right;}
              #main-menu {position: absolute;  top: 5.5em;  left:6px;}
              #main-menu ul {margin: 0;  padding: 0;}
              #main-menu li {
                float:left;
                list-style-type:none;
                margin: 0px 10px 0px 0px;
                padding: 0px 0px 0px 0px;
                white-space:nowrap;
              }
              #main-menu li a {
                display: block;
                color: #fff;
                text-decoration: none;
                margin: 0;
                padding: 4px 4px 4px 4px;
                background: #2C4056;
              }
              #main-menu li a:hover {background:#759FCF;}
              #main {background: url(../images/mainbg.png) repeat-x; background-color:#EEEEEE;}
              #sidebar{ float: right; width: 17%; position: relative; z-index: 9; min-height: 600px; padding: 0; margin: 0;}
              * html #sidebar{ width: 17%; }
              #sidebar h3{ font-size: 14px; margin-top:14px; color: #666;  }
              #sidebar hr{ width: 100%; margin: 0 auto; height: 1px; background: #ccc; border: 0; }
              * html #sidebar hr{ width: 95%; position: relative; left: -6px; color: #ccc; }
              #content { width: 80%; background: url(../images/contentbg.png) repeat-x; background-color: #fff; margin: 0px; border-right: 1px solid #ddd; padding: 6px 10px 10px 10px; position: relative; z-index: 10; height:600px; min-height: 600px;}
              * html #content{ width: 80%; padding-left: 0; margin-top: 0px; padding: 6px 10px 10px 10px;}
              html>body #content {
              height: auto;
              min-height: 600px;
              }
              #main.nosidebar #sidebar{ display: none; }
              #main.nosidebar #content{ width: auto; border-right: 0; }
              #footer {clear: both; border-top: 1px solid #bbb; font-size: 0.9em; color: #aaa; padding: 5px; text-align:center; background:#fff;}
              #login-form table {margin-top:5em; padding:1em; margin-left: auto; margin-right: auto; border: 2px solid #FDBF3B; background-color:#FFEBC1; }
              #login-form table td {padding: 6px;}
              #login-form label {font-weight: bold;}
              .clear:after{ content: "."; display: block; height: 0; clear: both; visibility: hidden; }
              /***** Links *****/
              a, a:link, a:visited{ color: #2A5685; text-decoration: none; }
              a:hover, a:active{ color: #c61a1a; text-decoration: underline;}
              a img{ border: 0; }
              /***** Tables *****/
              table.list { border: 1px solid #e4e4e4;  border-collapse: collapse; width: 100%; margin-bottom: 4px; }
              table.list th {  background-color:#EEEEEE; padding: 4px; white-space:nowrap; }
              table.list tbody th { padding: 0px; }
              table.list td { overflow: hidden; text-overflow: ellipsis; vertical-align: top;}
              table.list tbody tr:hover { background-color:#ffffdd; }
              table td {padding:2px;}
              table p {margin:0;}
              .odd {background-color:#f6f7f8;}
              .even {background-color: #fff;}
              .highlight { background-color: #FCFD8D;}
              .box{
              padding:6px;
              margin-bottom: 10px;
              background-color:#f6f6f6;
              color:#505050;
              line-height:1.5em;
              border: 1px solid #e4e4e4;
              }
              div.square {
               border: 1px solid #999;
               float: left;
               margin: .3em .4em 0 .4em;
               overflow: hidden;
               width: .6em; height: .6em;
              }
              .contextual {float:right; white-space: nowrap; line-height:1.4em;margin-top:5px;font-size:0.9em;}
              .splitcontentleft{float:left; width:49%;}
              .splitcontentright{float:right; width:49%;}
              form {display: inline;}
              input, select {vertical-align: middle; margin-top: 1px; margin-bottom: 1px;}
              fieldset {border: 1px solid #e4e4e4; margin:0;}
              hr { width: 100%; height: 1px; background: #ccc; border: 0;}
              textarea.wiki-edit { width: 99%; }
              li p {margin-top: 0;}
              div.issue {background:#ffffdd; padding:6px; margin-bottom:6px;border: 1px solid #d7d7d7;}
              .autoscroll {overflow-x: auto; padding:1px; width:100%;}
              /***** Tabular forms ******/
              .tabular p{
              margin: 0;
              padding: 5px 0 8px 0;
              padding-left: 180px; /*width of left column containing the label elements*/
              height: 1%;
              clear:left;
              }
              .tabular label{
              font-weight: bold;
              float: left;
              text-align: right;
              margin-left: -180px; /*width of left column*/
              width: 175px; /*width of labels. Should be smaller than left column to create some right
              margin*/
              }
              #settings .tabular p{ padding-left: 300px; }
              #settings .tabular label{ margin-left: -300px; width: 295px; }
              .required {color: #bb0000;}
              .summary {font-style: italic;}
              div.attachments p { margin:4px 0 2px 0; }
              /***** Issue list ****/
              tr.issue { text-align: center; white-space: nowrap; }
              tr.issue th.checkbox { width: 15px; }
              tr.issue td.subject, tr.issue td.category { white-space: normal; }
              tr.issue td.subject { text-align: left; }
              /***** Flash & error messages ****/
              #flash div, #errorExplanation, .nodata {
                  padding: 4px 4px 4px 30px;
                  margin-bottom: 12px;
              	font-size: 1.1em;
              	border: 2px solid;
              }
              #flash div {margin-top: 6px;}
              #flash div.error, #errorExplanation {
                  background: url(../images/false.png) 8px 5px no-repeat;
              	background-color: #ffe3e3;
              	border-color: #dd0000;
              	color: #550000;
              }
              #flash div.notice {
                  background: url(../images/true.png) 8px 5px no-repeat;
              	background-color: #dfffdf;
              	border-color: #9fcf9f;
              	color: #005f00;
              }
              .nodata {
                  text-align: center;
              	background-color: #FFEBC1;
              	border-color: #FDBF3B;
              	color: #A6750C;
              }
              #errorExplanation ul { font-size: 0.9em;}
              /***** Ajax indicator ******/
              #ajax-indicator {
              position: absolute; /* fixed not supported by IE */
              background-color:#eee;
              border: 1px solid #bbb;
              top:35%;
              left:40%;
              width:20%;
              font-weight:bold;
              text-align:center;
              padding:0.6em;
              z-index:100;
              filter:alpha(opacity=50);
              -moz-opacity:0.5;
              opacity: 0.5;
              -khtml-opacity: 0.5;
              }
              html>body #ajax-indicator { position: fixed; }
              #ajax-indicator span {
              background-position: 0% 40%;
              background-repeat: no-repeat;
              background-image: url(../images/loading.gif);
              padding-left: 26px;
              vertical-align: bottom;
              }
              /***** Calendar *****/
              table.cal {border-collapse: collapse; width: 100%; margin: 8px 0 6px 0;border: 1px solid #d7d7d7;}
              table.cal th { background-color:#EEEEEE; padding: 4px; }
              table.cal td {border: 1px solid #d7d7d7;}
              table.cal td.today {background:#ffffdd;}
              /***** Tooltips ******/
              .tooltip{position:relative;z-index:24;}
              .tooltip:hover{z-index:25;color:#000;}
              .tooltip span.tip{display: none; text-align:left;}
              div.tooltip:hover span.tip{
              display:block;
              position:absolute;
              top:12px; left:24px; width:270px;
              border:1px solid #555;
              background-color:#fff;
              padding: 4px;
              font-size: 0.8em;
              color:#505050;
              }
              /***** Progress bar *****/
              .progress {
                  border: 1px solid #D7D7D7;
                  border-collapse: collapse;
                  border-spacing: 0pt;
                  empty-cells: show;
                  padding: 3px;
                  width: 40em;
                  text-align: center;
              }
              .progress td { height: 1em; }
              .progress .closed { background: #BAE0BA none repeat scroll 0%; }
              .progress .open { background: #FFF none repeat scroll 0%; }
              /***** Tabs *****/
              #content .tabs{height: 2.6em;}
              #content .tabs ul{margin:0;}
              #content .tabs ul li{
              float:left;
              list-style-type:none;
              white-space:nowrap;
              margin-right:8px;
              background:#fff;
              }
              #content .tabs ul li a{
              display:block;
              font-size: 0.9em;
              text-decoration:none;
              line-height:1em;
              padding:4px;
              border: 1px solid #c0c0c0;
              }
              #content .tabs ul li a.selected, #content .tabs ul li a:hover{
              background-color: #507AAA;
              border: 1px solid #507AAA;
              color: #fff;
              text-decoration:none;
              }
              /***** Diff *****/
              .diff_out { background: #fcc; }
              .diff_in { background: #cfc; }
              /***** Wiki *****/
              div.wiki table {
                  border: 1px solid #505050;
                  border-collapse: collapse;
              }
              div.wiki table, div.wiki td, div.wiki th {
                  border: 1px solid #bbb;
                  padding: 4px;
              }
-             div.wiki a {
+             div.wiki .external {
                  background-position: 0% 60%;
                  background-repeat: no-repeat;
                  padding-left: 12px;
                  background-image: url(../images/external.png);
              }
-             div.wiki a.wiki-page, div.wiki a.issue, div.wiki a.changeset, div.wiki a.email, div.wiki div.toc a {
-                 padding-left: 0;
-                 background-image: none;
+             }
              div.wiki a.new {
                  color: #b73535;
              }
              div.wiki pre {
                  margin: 1em 1em 1em 1.6em;
                  padding: 2px;
                  background-color: #fafafa;
                  border: 1px solid #dadada;
                  width:95%;
                  overflow-x: auto;
              }
              div.wiki div.toc {
                  background-color: #ffffdd;
                  border: 1px solid #e4e4e4;
                  padding: 4px;
                  line-height: 1.2em;
                  margin-bottom: 12px;
                  margin-right: 12px;
                  display: table
              }
              * html div.wiki div.toc { width: 50%; } /* IE6 doesn't autosize div */
              div.wiki div.toc.right { float: right; margin-left: 12px; margin-right: 0; width: auto; }
              div.wiki div.toc.left  { float: left; margin-right: 12px; margin-left: 0; width: auto; }
              div.wiki div.toc a {
                  display: block;
                  font-size: 0.9em;
                  font-weight: normal;
                  text-decoration: none;
                  color: #606060;
              }
              div.wiki div.toc a:hover { color: #c61a1a; text-decoration: underline;}
              div.wiki div.toc a.heading2 { margin-left: 6px; }
              div.wiki div.toc a.heading3 { margin-left: 12px; font-size: 0.8em; }
              /***** My page layout *****/
              .block-receiver {
              border:1px dashed #c0c0c0;
              margin-bottom: 20px;
              padding: 15px 0 15px 0;
              }
              .mypage-box {
              margin:0 0 20px 0;
              color:#505050;
              line-height:1.5em;
              }
              .handle {
              cursor: move;
              }
              a.close-icon {
              display:block;
              margin-top:3px;
              overflow:hidden;
              width:12px;
              height:12px;
              background-repeat: no-repeat;
              cursor:pointer;
              background-image:url('../images/close.png');
              }
              a.close-icon:hover {
              background-image:url('../images/close_hl.png');
              }
              /***** Gantt chart *****/
              .gantt_hdr {
                position:absolute;
                top:0;
                height:16px;
                border-top: 1px solid #c0c0c0;
                border-bottom: 1px solid #c0c0c0;
                border-right: 1px solid #c0c0c0;
                text-align: center;
                overflow: hidden;
              }
              .task {
                position: absolute;
                height:8px;
                font-size:0.8em;
                color:#888;
                padding:0;
                margin:0;
                line-height:0.8em;
              }
              .task_late { background:#f66 url(../images/task_late.png); border: 1px solid #f66; }
              .task_done { background:#66f url(../images/task_done.png); border: 1px solid #66f; }
              .task_todo { background:#aaa url(../images/task_todo.png); border: 1px solid #aaa; }
              .milestone { background-image:url(../images/milestone.png); background-repeat: no-repeat; border: 0; }
              /***** Icons *****/
              .icon {
              background-position: 0% 40%;
              background-repeat: no-repeat;
              padding-left: 20px;
              padding-top: 2px;
              padding-bottom: 3px;
              }
              .icon22 {
              background-position: 0% 40%;
              background-repeat: no-repeat;
              padding-left: 26px;
              line-height: 22px;
              vertical-align: middle;
              }
              .icon-add { background-image: url(../images/add.png); }
              .icon-edit { background-image: url(../images/edit.png); }
              .icon-del { background-image: url(../images/delete.png); }
              .icon-move { background-image: url(../images/move.png); }
              .icon-save { background-image: url(../images/save.png); }
              .icon-cancel { background-image: url(../images/cancel.png); }
              .icon-pdf { background-image: url(../images/pdf.png); }
              .icon-csv { background-image: url(../images/csv.png); }
              .icon-html { background-image: url(../images/html.png); }
              .icon-image { background-image: url(../images/image.png); }
              .icon-txt { background-image: url(../images/txt.png); }
              .icon-file { background-image: url(../images/file.png); }
              .icon-folder { background-image: url(../images/folder.png); }
              .icon-package { background-image: url(../images/package.png); }
              .icon-home { background-image: url(../images/home.png); }
              .icon-user { background-image: url(../images/user.png); }
              .icon-mypage { background-image: url(../images/user_page.png); }
              .icon-admin { background-image: url(../images/admin.png); }
              .icon-projects { background-image: url(../images/projects.png); }
              .icon-logout { background-image: url(../images/logout.png); }
              .icon-help { background-image: url(../images/help.png); }
              .icon-attachment  { background-image: url(../images/attachment.png); }
              .icon-index  { background-image: url(../images/index.png); }
              .icon-history  { background-image: url(../images/history.png); }
              .icon-feed  { background-image: url(../images/feed.png); }
              .icon-time  { background-image: url(../images/time.png); }
              .icon-stats  { background-image: url(../images/stats.png); }
              .icon-warning  { background-image: url(../images/warning.png); }
              .icon-fav  { background-image: url(../images/fav.png); }
              .icon-fav-off  { background-image: url(../images/fav_off.png); }
              .icon-reload  { background-image: url(../images/reload.png); }
              .icon-lock  { background-image: url(../images/locked.png); }
              .icon-unlock  { background-image: url(../images/unlock.png); }
              .icon-note  { background-image: url(../images/note.png); }
              .icon22-projects { background-image: url(../images/22x22/projects.png); }
              .icon22-users { background-image: url(../images/22x22/users.png); }
              .icon22-tracker { background-image: url(../images/22x22/tracker.png); }
              .icon22-role { background-image: url(../images/22x22/role.png); }
              .icon22-workflow { background-image: url(../images/22x22/workflow.png); }
              .icon22-options { background-image: url(../images/22x22/options.png); }
              .icon22-notifications { background-image: url(../images/22x22/notifications.png); }
              .icon22-authent { background-image: url(../images/22x22/authent.png); }
              .icon22-info { background-image: url(../images/22x22/info.png); }
              .icon22-comment { background-image: url(../images/22x22/comment.png); }
              .icon22-package { background-image: url(../images/22x22/package.png); }
              .icon22-settings { background-image: url(../images/22x22/settings.png); }
              .icon22-plugin { background-image: url(../images/22x22/plugin.png); }
              /***** Media print specific styles *****/
              @media print {
                #top-menu, #header, #main-menu, #sidebar, #footer, .contextual { display:none; }
                #main { background: #fff; }
                #content { width: 99%; margin: 0; padding: 0; border: 0; background: #fff; }
              }

test/unit/helpers/application_helper_test.rb +9 -8

              # 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, :repositories, :changesets, :trackers, :issue_statuses, :issues
                def setup
                  super
                end
                def test_auto_links
                  to_test = {
-                   'http://foo.bar' => '<a href="http://foo.bar">http://foo.bar</a>',
-                   'http://foo.bar.' => '<a href="http://foo.bar">http://foo.bar</a>.',
-                   'http://foo.bar/foo.bar#foo.bar.' => '<a href="http://foo.bar/foo.bar#foo.bar">http://foo.bar/foo.bar#foo.bar</a>.',
-                   'www.foo.bar' => '<a href="http://www.foo.bar">www.foo.bar</a>',
-                   'http://foo.bar/page?p=1&t=z&s=' => '<a 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 href="http://foo.bar/page#125">http://foo.bar/page#125</a>'
+                   'http://foo.bar' => '<a class="external" href="http://foo.bar">http://foo.bar</a>',
+                   'http://foo.bar.' => '<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>.',
+                   '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>'
                  }
                  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_textile_tags
                  to_test = {
                    # inline images
                    '!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>',
                    # textile links
-                   'This is a "link":http://foo.bar' => 'This is a <a href="http://foo.bar">link</a>',
-                   '"link (Link title)":http://foo.bar' => '<a href="http://foo.bar" title="Link title">link</a>'
+                   '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>'
                  }
                  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 => 1, :rev => 1},
                                                 :class => 'changeset', :title => 'My very first commit')
                  to_test = {
                    '#3, #3 and #3.' => "#{issue_link}, #{issue_link} and #{issue_link}.",
                    'r1' => changeset_link
                  }
                  @project = Project.find(1)
                  to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
                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