Pimki 1.0.092

data/app/models/author.rb

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

data/app/models/chunks/category.rb

@@ -0,0 +1,31 @@
+require 'chunks/chunk'
+
+# The category chunk looks for "category: news" on a line by
+# itself and parses the terms after the ':' as categories.
+# Other classes can search for Category chunks within
+# rendered content to find out what categories this page
+# should be in.
+#
+# Category lines can be hidden using ':category: news', for example
+class Category < Chunk::Abstract
+  def self.pattern() return /^(:)?category\s*:(.*)$/i end
+
+  attr_reader :hidden, :list
+
+  def initialize(match_data)
+    super(match_data)
+    @hidden = match_data[1]
+    @list = match_data[2].split(',').map { |c| c.strip }
+  end
+
+  # Mark this chunk's start and end points but allow the terms
+  # after the ':' to be marked up.
+  def mask(content) pre_mask + list.join(', ') + post_mask end
+
+  # If the chunk is hidden, erase the mask and return this chunk
+  # otherwise, surround it with a 'div' block.
+  def unmask(content)
+    replacement = ( hidden ? '' : '<div class="property">category:\1</div>' )
+    self if content.sub!( Regexp.new( pre_mask+'(.*)?'+post_mask ), replacement )
+  end
+end

data/app/models/chunks/category_test.rb

@@ -0,0 +1,21 @@
+require 'chunks/category'
+require 'chunks/match'
+require 'test/unit'
+
+class CategoryTest < Test::Unit::TestCase
+  include ChunkMatch
+
+  def test_single_category
+	match(Category, 'category: test', :list => ['test'], :hidden => nil)
+	match(Category, 'category :   chunk test   ', :list => ['chunk test'], :hidden => nil)
+	match(Category, ':category: test', :list => ['test'], :hidden => ':')
+  end
+
+  def test_multiple_categories
+	match(Category, 'category: test, multiple', :list => ['test', 'multiple'], :hidden => nil)
+	match(Category, 'category : chunk test , multi category,regression test case  ', 
+		:list => ['chunk test','multi category','regression test case'], :hidden => nil
+	)
+  end
+
+end

data/app/models/chunks/chunk.rb

@@ -0,0 +1,20 @@
+require 'digest/md5'
+require 'uri/common'
+
+# A chunk is a pattern of text that can be protected
+# and interrogated by a renderer. Each Chunk class has a 
+# +pattern+ that states what sort of text it matches.
+# Chunks are initalized by passing in the result of a
+# match by its pattern. 
+module Chunk
+  class Abstract
+	attr_reader :text
+
+	def initialize(match_data) @text = match_data[0] 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 revert(content) content.sub!( Regexp.new(mask(content)), text ) end
+	def unmask(content) self if revert(content) end
+  end
+end

data/app/models/chunks/engines.rb

@@ -0,0 +1,34 @@
+require 'rdocsupport'
+require 'chunks/chunk'
+
+# The markup engines are Chunks that call the one of RedCloth, BlueCloth
+# or RDoc to convert text. This markup occurs when the chunk is required
+# to mask itself.
+module Engines
+  class Textile < Chunk::Abstract
+    def self.pattern() /^(.*)$/m end
+    def mask(content)
+      RedCloth.new(text,content.options[:engine_opts]).to_html
+    end
+    def unmask(content) self end
+  end
+
+  class Markdown < Chunk::Abstract
+    def self.pattern() /^(.*)$/m end
+    def mask(content)
+      BlueCloth.new(text,content.options[:engine_opts]).to_html
+    end
+    def unmask(content) self end
+  end
+
+  class RDoc < Chunk::Abstract
+    def self.pattern() /^(.*)$/m end
+    def mask(content)
+      RDocSupport::RDocFormatter.new(text).to_html
+    end
+    def unmask(content) self end
+  end
+
+  MAP = { :textile => Textile, :markdown => Markdown, :rdoc => RDoc }
+end
+

data/app/models/chunks/include.rb

@@ -0,0 +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)
+    super(match_data)
+    @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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +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

data/app/models/chunks/nowiki.rb

@@ -0,0 +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)
+	super(match_data)
+	@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

@@ -0,0 +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

data/app/models/chunks/test.rb

@@ -0,0 +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

data/app/models/chunks/todo.rb

@@ -0,0 +1,22 @@
+require 'chunks/wiki'
+require 'date'
+require 'parsedate'
+
+# ToDo items.
+class Todo < Chunk::Abstract
+  def self.pattern() /todo: ([^\n]+)/i end
+
+  def initialize(match_data)
+    super(match_data)
+  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.gsub(/todo:\s*/, '')}</span>" )
+  end
+end

data/app/models/chunks/uri.rb

@@ -0,0 +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})" 
+
+  # 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)
+    super(match_data)
+    # 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

data/app/models/chunks/uri_test.rb

@@ -0,0 +1,92 @@
+require 'chunks/uri'
+require 'chunks/match'
+require 'test/unit'
+
+class URITest < Test::Unit::TestCase
+  include ChunkMatch
+
+  def test_non_matches
+    assert_no_match(URIChunk.pattern, 'There is no URI here') 
+    assert_no_match(URIChunk.pattern, 'One gemstone is the garnet:reddish in colour, like ruby') 
+  end
+
+  def test_simple_uri
+    match(URIChunk, 'http://www.example.com',
+		:scheme =>'http', :host =>'www.example.com', :path => nil,
+		:link_text => 'http://www.example.com'
+	)
+    match(URIChunk, 'http://www.example.com/',
+		:scheme =>'http', :host =>'www.example.com', :path => '/',
+		:link_text => 'http://www.example.com/'
+	)
+    match(URIChunk, 'www.example.com', 
+		:scheme =>'http', :host =>'www.example.com', :link_text => 'www.example.com'
+	)
+    match(URIChunk, 'example.com', 
+		:scheme =>'http',:host =>'example.com', :link_text => 'example.com'
+    )
+    match(URIChunk, 'http://example.com.au/', 
+		:scheme =>'http', :host =>'example.com.au', :link_text => 'http://example.com.au/'
+	)
+    match(URIChunk, 'example.com.au',  
+		:scheme =>'http', :host =>'example.com.au', :link_text => 'example.com.au'
+	)
+    match(URIChunk, 'http://www.example.co.uk/',
+		:scheme =>'http', :host =>'www.example.co.uk',
+		:link_text => 'http://www.example.co.uk/'
+	)
+    match(URIChunk, 'example.co.uk',
+		:scheme =>'http', :host =>'example.co.uk', :link_text => 'example.co.uk'
+	)
+	match(URIChunk, 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation',
+		:scheme => 'http', :host => 'moinmoin.wikiwikiweb.de', :path => '/HelpOnNavigation',
+		:link_text => 'http://moinmoin.wikiwikiweb.de/HelpOnNavigation'
+	)
+	match(URIChunk, 'moinmoin.wikiwikiweb.de/HelpOnNavigation',
+		:scheme => 'http', :host => 'moinmoin.wikiwikiweb.de', :path => '/HelpOnNavigation',
+		:link_text => 'moinmoin.wikiwikiweb.de/HelpOnNavigation'
+	)
+  end
+
+  def test_email_uri
+	match(URIChunk, 'mail@example.com', 
+		:user => 'mail', :host => 'example.com', :link_text => 'mail@example.com'
+	)
+  end
+
+  def test_non_email
+	# The @ is part of the normal text, but 'example.com' is marked up.
+	match(URIChunk, 'Not an email: @example.com', :user => nil, :uri => 'http://example.com')
+  end
+
+  def test_non_uri
+	assert_no_match(URIChunk.pattern, 'httpd.conf')
+	assert_no_match(URIChunk.pattern, 'libproxy.so')
+  end
+
+  def test_uri_in_text
+    match(URIChunk, 'Go to: http://www.example.com/', :host => 'www.example.com', :path =>'/')
+    match(URIChunk, 'http://www.example.com/ is a link.', :host => 'www.example.com')
+    match(URIChunk, 
+      'Email david@loudthinking.com', 
+      :scheme =>'mailto', :user =>'david', :host =>'loudthinking.com'
+    )
+  end
+
+  def test_uri_in_parentheses
+    match(URIChunk, 'URI (http://brackets.com.de) in brackets', :host => 'brackets.com.de')
+    match(URIChunk, 'because (as shown at research.net) the results', :host => 'research.net')
+    match(URIChunk, 
+      'A wiki (http://wiki.org/wiki.cgi?WhatIsWiki) page', 
+      :scheme => 'http', :host => 'wiki.org', :path => '/wiki.cgi', :query => 'WhatIsWiki'
+    )
+  end
+  
+  def test_uri_list_item
+    match(
+      URIChunk, 
+      '* http://www.btinternet.com/~mail2minh/SonyEricssonP80xPlatform.sis', 
+      :path => '/~mail2minh/SonyEricssonP80xPlatform.sis'
+    )
+  end
+end