Pimki 1.3.092 → 1.4.092

data/app/models/author.rb

@@ -1,4 +1,4 @@
-class Author < String
-  attr_accessor :ip
-  def initialize(name, ip) @ip = ip; super(name) end
+class Author < String
+  attr_accessor :ip
+  def initialize(name, ip) @ip = ip; super(name) end
 end

data/app/models/chunks/chunk.rb

@@ -11,9 +11,9 @@ module Chunk
 	attr_reader :text, :revision
 
 	def initialize(match_data, revision) @text = match_data[0]; @revision = revision end
-	def pre_mask() "chunk#{self.id}start " end
-	def post_mask() " chunk#{self.id}end" end
-	def mask(content) "chunk#{self.id}chunk" end
+	def pre_mask() "chunk#{self.object_id}start " end
+	def post_mask() " chunk#{self.object_id}end" end
+	def mask(content) "chunk#{self.object_id}chunk" end
 	def revert(content) content.sub!( Regexp.new(mask(content)), text ) end
 	def unmask(content) self if revert(content) end
   end

data/app/models/chunks/engines.rb

@@ -5,43 +5,40 @@ require 'chunks/chunk'
 # or RDoc to convert text. This markup occurs when the chunk is required
 # to mask itself.
 module Engines
-  class Textile < Chunk::Abstract
+  
+  class MarkupEngine < Chunk::Abstract
     def self.pattern() /^(.*)$/m end
+    def unmask(content) self end
+  end
+  
+  class Textile < MarkupEngine
     def mask(content)
-      #RedCloth.new(text,content.options[:engine_opts]).to_html
       rc = RedCloth.new(text,content.options[:engine_opts])
       rc.rules = [:textile]
       rc.to_html
     end
-    def unmask(content) self end
   end
 
-  class Markdown < Chunk::Abstract
-    def self.pattern() /^(.*)$/m end
-    
-    if RedCloth::VERSION >= '3.0.0'
-      def mask(content)
-        rc = RedCloth.new(text,content.options[:engine_opts])
-        rc.rules = [:markdown]
-        rc.to_html
-      end
-    else
-      def mask(content)
-        BlueCloth.new(text,content.options[:engine_opts]).to_html
-      end
+  class RedMarkdown < MarkupEngine
+    def mask(content)
+      rc = RedCloth.new(text,content.options[:engine_opts])
+      rc.rules = [:markdown]
+      rc.to_html
     end
+  end
 
-    def unmask(content) self end
+  class BlueMarkdown < MarkupEngine
+    def mask(content)
+      BlueCloth.new(text,content.options[:engine_opts]).to_html
+    end
   end
 
-  class RDoc < Chunk::Abstract
-    def self.pattern() /^(.*)$/m end
+  class RDoc < MarkupEngine
     def mask(content)
       RDocSupport::RDocFormatter.new(text).to_html
     end
-    def unmask(content) self end
   end
 
-  MAP = { :textile => Textile, :markdown => Markdown, :rdoc => RDoc }
+  MAP = { :textile => Textile, :red_markdown => RedMarkdown, :blue_markdown => BlueMarkdown, :rdoc => RDoc }
 end
 

data/app/models/chunks/include.rb

@@ -1,29 +1,29 @@
-require 'chunks/wiki'
-
-# Includes the contents of another page for rendering.
-# The include command looks like this: "[[!include PageName]]".
-# It is a WikiLink since it refers to another page (PageName)
-# and the wiki content using this command must be notified
-# of changes to that page.
-# If the included page could not be found, a warning is displayed.
-class Include < WikiChunk::WikiLink
-  def self.pattern() /^\[\[!include(.*)\]\]\s*$/i end
-
-  attr_reader :page_name
-
-  def initialize(match_data, revision)
-    super(match_data, revision)
-    @page_name = match_data[1].strip
-  end
-
-  # This replaces the [[!include PageName]] text with
-  # the contents of PageName if it exists. Otherwise
-  # a warning is displayed.
-  def mask(content) 
-    page = content.web.pages[page_name]
-    (page ? page.content : "<em>Could not include #{page_name}</em>")
-  end
-
-  # Keep this chunk regardless of what happens.
-  def unmask(content) self end
-end
+require 'chunks/wiki'
+
+# Includes the contents of another page for rendering.
+# The include command looks like this: "[[!include PageName]]".
+# It is a WikiLink since it refers to another page (PageName)
+# and the wiki content using this command must be notified
+# of changes to that page.
+# If the included page could not be found, a warning is displayed.
+class Include < WikiChunk::WikiLink
+  def self.pattern() /^\[\[!include(.*)\]\]\s*$/i end
+
+  attr_reader :page_name
+
+  def initialize(match_data, revision)
+    super(match_data, revision)
+    @page_name = match_data[1].strip
+  end
+
+  # This replaces the [[!include PageName]] text with
+  # the contents of PageName if it exists. Otherwise
+  # a warning is displayed.
+  def mask(content) 
+    page = content.web.pages[page_name]
+    (page ? page.content : "<em>Could not include #{page_name}</em>")
+  end
+
+  # Keep this chunk regardless of what happens.
+  def unmask(content) self end
+end

data/app/models/chunks/literal.rb

@@ -1,20 +1,20 @@
-require 'chunks/chunk'
-
-# These are basic chunks that have a pattern and can be protected.
-# They are used by rendering process to prevent wiki rendering
-# occuring within literal areas such as <code> and <pre> blocks
-# and within HTML tags.
-module Literal
-  # A literal chunk that protects 'code' and 'pre' tags from wiki rendering.
-  class Pre < Chunk::Abstract
-    PRE_BLOCKS = "a|pre|code"
-    def self.pattern() Regexp.new('<('+PRE_BLOCKS+')\b[^>]*?>.*?</\1>', Regexp::MULTILINE) end
-  end 
-
-  # A literal chunk that protects HTML tags from wiki rendering.
-  class Tags < Chunk::Abstract
-    TAGS = "a|img|em|strong|div|span|table|td|th|ul|ol|li|dl|dt|dd"
-    def self.pattern() Regexp.new('<(?:'+TAGS+')[^>]*?>', Regexp::MULTILINE) end
-  end
-end
-
+require 'chunks/chunk'
+
+# These are basic chunks that have a pattern and can be protected.
+# They are used by rendering process to prevent wiki rendering
+# occuring within literal areas such as <code> and <pre> blocks
+# and within HTML tags.
+module Literal
+  # A literal chunk that protects 'code' and 'pre' tags from wiki rendering.
+  class Pre < Chunk::Abstract
+    PRE_BLOCKS = "a|pre|code"
+    def self.pattern() Regexp.new('<('+PRE_BLOCKS+')\b[^>]*?>.*?</\1>', Regexp::MULTILINE) end
+  end 
+
+  # A literal chunk that protects HTML tags from wiki rendering.
+  class Tags < Chunk::Abstract
+    TAGS = "a|img|em|strong|div|span|table|td|th|ul|ol|li|dl|dt|dd"
+    def self.pattern() Regexp.new('<(?:'+TAGS+')[^>]*?>', Regexp::MULTILINE) end
+  end
+end
+

data/app/models/chunks/match.rb

@@ -1,19 +1,19 @@
-# This module is to be included in unit tests that involve matching chunks.
-# It provides a easy way to test whether a chunk matches a particular string
-# and any the values of any fields that should be set after a match.
-module ChunkMatch
-
-  # Asserts a number of tests for the given type and text.
-  def match(type, test_text, expected)
-	pattern = type.pattern
-    assert_match(pattern, test_text)
-    pattern =~ test_text   # Previous assertion guarantees match
-    chunk = type.new($~)
-    
-    # Test if requested parts are correct.
-    for method_sym, value in expected do
-      assert_respond_to(chunk, method_sym)
-      assert_equal(value, chunk.method(method_sym).call, "Checking value of '#{method_sym}'")
-    end
-  end
-end
+# This module is to be included in unit tests that involve matching chunks.
+# It provides a easy way to test whether a chunk matches a particular string
+# and any the values of any fields that should be set after a match.
+module ChunkMatch
+
+  # Asserts a number of tests for the given type and text.
+  def match(type, test_text, expected)
+	pattern = type.pattern
+    assert_match(pattern, test_text)
+    pattern =~ test_text   # Previous assertion guarantees match
+    chunk = type.new($~)
+    
+    # Test if requested parts are correct.
+    for method_sym, value in expected do
+      assert_respond_to(chunk, method_sym)
+      assert_equal(value, chunk.method(method_sym).call, "Checking value of '#{method_sym}'")
+    end
+  end
+end

data/app/models/chunks/nowiki.rb

@@ -1,31 +1,31 @@
-require 'chunks/chunk'
-
-# This chunks allows certain parts of a wiki page to be hidden from the
-# rest of the rendering pipeline. It should be run at the beginning
-# of the pipeline in `wiki_content.rb`.
-#
-# An example use of this chunk is to markup double brackets or
-# auto URI links:
-#  <nowiki>Here are [[double brackets]] and a URI: www.uri.org</nowiki>
-#
-# The contents of the chunks will not be processed by any other chunk
-# so the `www.uri.org` and the double brackets will appear verbatim.
-#
-# Author: Mark Reid <mark at threewordslong dot com>
-# Created: 8th June 2004
-class NoWiki < Chunk::Abstract
-
-  def self.pattern() Regexp.new('<nowiki>(.*?)</nowiki>') end
-
-  attr_reader :plain_text
-
-  def initialize(match_data, revision)
-	super(match_data, revision)
-	@plain_text = match_data[1]
-  end
-  
-  # The nowiki content is not unmasked. This means the chunk will be reverted
-  # using the plain text.
-  def unmask(content) nil end
-  def revert(content) content.sub!( Regexp.new(mask(content)), plain_text ) end
-end
+require 'chunks/chunk'
+
+# This chunks allows certain parts of a wiki page to be hidden from the
+# rest of the rendering pipeline. It should be run at the beginning
+# of the pipeline in `wiki_content.rb`.
+#
+# An example use of this chunk is to markup double brackets or
+# auto URI links:
+#  <nowiki>Here are [[double brackets]] and a URI: www.uri.org</nowiki>
+#
+# The contents of the chunks will not be processed by any other chunk
+# so the `www.uri.org` and the double brackets will appear verbatim.
+#
+# Author: Mark Reid <mark at threewordslong dot com>
+# Created: 8th June 2004
+class NoWiki < Chunk::Abstract
+
+  def self.pattern() Regexp.new('<nowiki>(.*?)</nowiki>') end
+
+  attr_reader :plain_text
+
+  def initialize(match_data, revision)
+	super(match_data, revision)
+	@plain_text = match_data[1]
+  end
+  
+  # The nowiki content is not unmasked. This means the chunk will be reverted
+  # using the plain text.
+  def unmask(content) nil end
+  def revert(content) content.sub!( Regexp.new(mask(content)), plain_text ) end
+end

data/app/models/chunks/nowiki_test.rb

@@ -1,14 +1,14 @@
-require 'chunks/nowiki'
-require 'chunks/match'
-require 'test/unit'
-
-class NoWikiTest < Test::Unit::TestCase
-  include ChunkMatch
-
-  def test_simple_nowiki
-	match(NoWiki, 'This sentence contains <nowiki>[[raw text]]</nowiki>. Do not touch!',
-		:plain_text => '[[raw text]]'
-	)
-  end
-
-end
+require 'chunks/nowiki'
+require 'chunks/match'
+require 'test/unit'
+
+class NoWikiTest < Test::Unit::TestCase
+  include ChunkMatch
+
+  def test_simple_nowiki
+	match(NoWiki, 'This sentence contains <nowiki>[[raw text]]</nowiki>. Do not touch!',
+		:plain_text => '[[raw text]]'
+	)
+  end
+
+end

data/app/models/chunks/test.rb

@@ -1,18 +1,18 @@
-require 'test/unit'
-
-class ChunkTest < Test::Unit::TestCase
-
-  # Asserts a number of tests for the given type and text.
-  def match(type, test_text, expected)
-	pattern = type.pattern
-    assert_match(pattern, test_text)
-    pattern =~ test_text   # Previous assertion guarantees match
-    chunk = type.new($~)
-    
-    # Test if requested parts are correct.
-    for method_sym, value in expected do
-      assert_respond_to(chunk, method_sym)
-      assert_equal(value, chunk.method(method_sym).call, "Checking value of '#{method_sym}'")
-    end
-  end
-end
+require 'test/unit'
+
+class ChunkTest < Test::Unit::TestCase
+
+  # Asserts a number of tests for the given type and text.
+  def match(type, test_text, expected)
+	pattern = type.pattern
+    assert_match(pattern, test_text)
+    pattern =~ test_text   # Previous assertion guarantees match
+    chunk = type.new($~)
+    
+    # Test if requested parts are correct.
+    for method_sym, value in expected do
+      assert_respond_to(chunk, method_sym)
+      assert_equal(value, chunk.method(method_sym).call, "Checking value of '#{method_sym}'")
+    end
+  end
+end

data/app/models/chunks/todo.rb

@@ -1,23 +1,44 @@
-require 'chunks/wiki'
-require 'date'
-require 'parsedate'
-
-# ToDo items.
-class Todo < Chunk::Abstract
-  def self.pattern() /todo: (.*?)(?=<br|\r|\n|\z)/i end
-
-  def initialize(match_data, revision)
-    super(match_data, revision)
-    @text = match_data[1]
-  end
-
-  def escaped_text() nil end
-
-  def unmask(content) 
-    return self if content.gsub!( Regexp.new(mask(content)),
-      # the style 'todo' is bright-red to be eye catching. It is not expected that
-      # there will be too many items on one page, but each is supposed to stand out.
-      # The ToDo special page differentiates between the 'todo' and 'todoFuture' styles.
-      "<span class=\"todo\"><strong>TODO:</strong> #{@text}</span>" )
-  end
-end
+require 'chunks/wiki'
+require 'date'
+require 'parsedate'
+
+# ToDo items.
+class Todo < Chunk::Abstract
+  def self.pattern() /todo(@[\w,]+)?: (.*?)(?=<br|\r|\n|\z)/i end
+
+  attr_accessor :context, :due_date
+
+  def initialize(match_data, revision)
+    super(match_data, revision)
+    @context = match_data[1]
+    @context = @context.nil? || @context.empty? ? [] : @context.delete('@').split(',')
+    @text = match_data[2]
+    begin
+      d = ParseDate.parsedate(@text)
+      # see if there's a date in the todo:
+      if not d.all? { |x| x.nil? }
+        d = d[0..2]
+        # sanity check the order retured from ParseDate: stuff like 'Jan 2005' 
+        # will be returned in inverse order to '12 Jan 2005'. (ie. no automatic bounds checking)
+        d.reverse! if d[2] > 31
+        # get the [year,month,date] with sane values if you miss the day/year.
+        # this should allow users to specify stuff like 'Dec 2005' or 'Dec 21'.
+        d = [ d[0] || Date.today.year, d[1], d[2] || 1 ]
+        @due_date = Date.new(*d)
+      end
+    rescue => detail
+      p ['==>', detail, @text]
+      @due_date = nil
+    end
+  end
+
+  def escaped_text() nil end
+
+  def unmask(content) 
+    return self if content.gsub!( Regexp.new(mask(content)),
+      # the style 'todo' is bright-red to be eye catching. It is not expected that
+      # there will be too many items on one page, but each is supposed to stand out.
+      # The ToDo special page differentiates between the 'todo' and 'todoFuture' styles.
+      "<todo-tag context='#{@context.join(',')}' due_date='#{@due_date}'><span class=\"todo\"><strong>TODO#{ " @ #{@context.join(', ')}" unless @context.empty?}:</strong> #{@text}</span></todo-tag>" )
+  end
+end

data/app/models/chunks/uri.rb

@@ -1,97 +1,97 @@
-require 'chunks/chunk'
-
-# This wiki chunk matches arbitrary URIs, using patterns from the Ruby URI modules.
-# It parses out a variety of fields that could be used by renderers to format
-# the links in various ways (shortening domain names, hiding email addresses)
-# It matches email addresses and host.com.au domains without schemes (http://)
-# but adds these on as required.
-#
-# The heuristic used to match a URI is designed to err on the side of caution.
-# That is, it is more likely to not autolink a URI than it is to accidently
-# autolink something that is not a URI. The reason behind this is it is easier
-# to force a URI link by prefixing 'http://' to it than it is to escape and
-# incorrectly marked up non-URI.
-#
-# I'm using a part of the [ISO 3166-1 Standard][iso3166] for country name suffixes.
-# The generic names are from www.bnoack.com/data/countrycode2.html)
-#   [iso3166]: http://geotags.com/iso3166/
-class URIChunk < Chunk::Abstract
-  include URI::REGEXP::PATTERN
-
-  GENERIC = '(?:aero|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org)'
-  COUNTRY = '(?:au|at|be|ca|ch|de|dk|fr|hk|in|ir|it|jp|nl|no|pt|ru|se|sw|tv|tw|uk|us)'
-
-  # These are needed otherwise HOST will match almost anything
-  TLDS = "\\.(?:#{GENERIC}|#{COUNTRY})\b" 
-
-  # Redefine USERINFO so that it must have non-zero length
-  USERINFO = "(?:[#{UNRESERVED};:&=+$,]|#{ESCAPED})+"
-
-  # Pattern of legal URI endings to stop interference with some Textile
-  # markup. (Images: !URI!) and other punctuation eg, (http://wiki.com/)
-  URI_ENDING = '[)!]'
-
-  # The basic URI expression as a string
-  URI_PATTERN = 
-	"(?:(#{SCHEME})://)?" +    # Optional scheme://              (\1|\8)
-	"(?:(#{USERINFO})@)?" +    # Optional userinfo@              (\2|\9)
-	"(#{HOSTNAME}#{TLDS})" +   # Mandatory host eg, HOST.com.au  (\3|\10)
-	"(?::(#{PORT}))?" +        # Optional :port                  (\4|\11)
-	"(#{ABS_PATH})?" +         # Optional absolute path          (\5|\12)
-	"(?:\\?(#{QUERY}))?" +     # Optional ?query                 (\6|\13)
-	"(?:\\#(#{FRAGMENT}))?"    # Optional #fragment              (\7|\14)
-
-  def self.pattern()
-    # This pattern first tries to match the URI_PATTERN that ends with 
-    # punctuation that is a valid URI character (eg, ')', '!'). If
-    # such a match occurs, there should be no backtracking (hence the ?> ). 
-    # If the string cannot match a URI ending with URI_ENDING, then a second
-    # attempt is tried.
-    Regexp.new("(?>#{URI_PATTERN}(?=#{URI_ENDING}))|#{URI_PATTERN}", Regexp::EXTENDED, 'N')
-  end
-
-  attr_reader :uri, :scheme, :user, :host, :port, :path, :query, :fragment, :link_text
-  
-  def initialize(match_data, revision)
-    super(match_data, revision)
-    # Since the URI_PATTERN is tried twice, there are two sets of
-    # groups, one from \1 to \7 and the second from \8 to \14.
-    # The fields are set by which ever group matches.
-    @scheme   	= match_data[1] || match_data[8]
-    @user     	= match_data[2] || match_data[9]
-    @host     	= match_data[3] || match_data[10]
-    @port		    = match_data[4] || match_data[11]
-    @path		    = match_data[5] || match_data[12]
-    @query		  = match_data[6] || match_data[13]
-    @fragment 	= match_data[7] || match_data[14]
-
-    # If there is no scheme, add an appropriate one, otherwise
-    # set the URI to the matched text.
-    @text_scheme = scheme
-    @uri = (scheme ? match_data[0] : nil )
-    @scheme = scheme || ( user ? 'mailto' : 'http' )
-    @delimiter = ( scheme == 'mailto' ? ':' : '://' ) 
-    @uri ||= scheme + @delimiter + match_data[0]
-
-    # Build up the link text. Schemes are omitted unless explicitly given.
-    @link_text = ''
-    @link_text << "#{@scheme}#{@delimiter}" if @text_scheme
-    @link_text << "#{@user}@" if @user
-    @link_text << "#{@host}" if @host
-    @link_text << ":#{@port}" if @port
-    @link_text << "#{@path}" if @path
-    @link_text << "?#{@query}" if @query
-  end
-
-  # If the text should be escaped then don't keep this chunk.
-  # Otherwise only keep this chunk if it was substituted back into the
-  # content.
-  def unmask(content) 
-    return nil if escaped_text
-    return self if content.sub!( Regexp.new(mask(content)), "<a href=\"#{uri}\">#{link_text}</a>" )
-  end
-
-  # If there is no hostname in the URI, do not render it
-  # It's probably only contains the scheme, eg 'something:' 
-  def escaped_text() ( host.nil? ? @uri : nil )  end
-end
+require 'chunks/chunk'
+
+# This wiki chunk matches arbitrary URIs, using patterns from the Ruby URI modules.
+# It parses out a variety of fields that could be used by renderers to format
+# the links in various ways (shortening domain names, hiding email addresses)
+# It matches email addresses and host.com.au domains without schemes (http://)
+# but adds these on as required.
+#
+# The heuristic used to match a URI is designed to err on the side of caution.
+# That is, it is more likely to not autolink a URI than it is to accidently
+# autolink something that is not a URI. The reason behind this is it is easier
+# to force a URI link by prefixing 'http://' to it than it is to escape and
+# incorrectly marked up non-URI.
+#
+# I'm using a part of the [ISO 3166-1 Standard][iso3166] for country name suffixes.
+# The generic names are from www.bnoack.com/data/countrycode2.html)
+#   [iso3166]: http://geotags.com/iso3166/
+class URIChunk < Chunk::Abstract
+  include URI::REGEXP::PATTERN
+
+  GENERIC = '(?:aero|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org)'
+  COUNTRY = '(?:au|at|be|ca|ch|de|dk|fr|hk|in|ir|it|jp|nl|no|pt|ru|se|sw|tv|tw|uk|us)'
+
+  # These are needed otherwise HOST will match almost anything
+  TLDS = "\\.(?:#{GENERIC}|#{COUNTRY})\b" 
+
+  # Redefine USERINFO so that it must have non-zero length
+  USERINFO = "(?:[#{UNRESERVED};:&=+$,]|#{ESCAPED})+"
+
+  # Pattern of legal URI endings to stop interference with some Textile
+  # markup. (Images: !URI!) and other punctuation eg, (http://wiki.com/)
+  URI_ENDING = '[)!]'
+
+  # The basic URI expression as a string
+  URI_PATTERN = 
+	"(?:(#{SCHEME})://)?" +    # Optional scheme://              (\1|\8)
+	"(?:(#{USERINFO})@)?" +    # Optional userinfo@              (\2|\9)
+	"(#{HOSTNAME}#{TLDS})" +   # Mandatory host eg, HOST.com.au  (\3|\10)
+	"(?::(#{PORT}))?" +        # Optional :port                  (\4|\11)
+	"(#{ABS_PATH})?" +         # Optional absolute path          (\5|\12)
+	"(?:\\?(#{QUERY}))?" +     # Optional ?query                 (\6|\13)
+	"(?:\\#(#{FRAGMENT}))?"    # Optional #fragment              (\7|\14)
+
+  def self.pattern()
+    # This pattern first tries to match the URI_PATTERN that ends with 
+    # punctuation that is a valid URI character (eg, ')', '!'). If
+    # such a match occurs, there should be no backtracking (hence the ?> ). 
+    # If the string cannot match a URI ending with URI_ENDING, then a second
+    # attempt is tried.
+    Regexp.new("(?>#{URI_PATTERN}(?=#{URI_ENDING}))|#{URI_PATTERN}", Regexp::EXTENDED, 'N')
+  end
+
+  attr_reader :uri, :scheme, :user, :host, :port, :path, :query, :fragment, :link_text
+  
+  def initialize(match_data, revision)
+    super(match_data, revision)
+    # Since the URI_PATTERN is tried twice, there are two sets of
+    # groups, one from \1 to \7 and the second from \8 to \14.
+    # The fields are set by which ever group matches.
+    @scheme   	= match_data[1] || match_data[8]
+    @user     	= match_data[2] || match_data[9]
+    @host     	= match_data[3] || match_data[10]
+    @port		    = match_data[4] || match_data[11]
+    @path		    = match_data[5] || match_data[12]
+    @query		  = match_data[6] || match_data[13]
+    @fragment 	= match_data[7] || match_data[14]
+
+    # If there is no scheme, add an appropriate one, otherwise
+    # set the URI to the matched text.
+    @text_scheme = scheme
+    @uri = (scheme ? match_data[0] : nil )
+    @scheme = scheme || ( user ? 'mailto' : 'http' )
+    @delimiter = ( scheme == 'mailto' ? ':' : '://' ) 
+    @uri ||= scheme + @delimiter + match_data[0]
+
+    # Build up the link text. Schemes are omitted unless explicitly given.
+    @link_text = ''
+    @link_text << "#{@scheme}#{@delimiter}" if @text_scheme
+    @link_text << "#{@user}@" if @user
+    @link_text << "#{@host}" if @host
+    @link_text << ":#{@port}" if @port
+    @link_text << "#{@path}" if @path
+    @link_text << "?#{@query}" if @query
+  end
+
+  # If the text should be escaped then don't keep this chunk.
+  # Otherwise only keep this chunk if it was substituted back into the
+  # content.
+  def unmask(content) 
+    return nil if escaped_text
+    return self if content.sub!( Regexp.new(mask(content)), "<a href=\"#{uri}\">#{link_text}</a>" )
+  end
+
+  # If there is no hostname in the URI, do not render it
+  # It's probably only contains the scheme, eg 'something:' 
+  def escaped_text() ( host.nil? ? @uri : nil )  end
+end