instiki 0.9.2

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/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.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
+end

data/app/models/chunks/engines.rb

@@ -0,0 +1,38 @@
+$: << File.dirname(__FILE__) + "../../libraries"
+
+require 'redcloth'
+require 'bluecloth'
+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/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/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/wiki.rb

@@ -0,0 +1,82 @@
+require 'wiki_words'
+require 'chunks/chunk'
+require 'cgi'
+
+# Contains all the methods for finding and replacing wiki related
+# links.
+module WikiChunk
+  include Chunk
+
+  # A wiki link is the top-level class for anything that refers to
+  # another wiki page.
+  class WikiLink < Chunk::Abstract
+    # By default, no escaped text
+    def escaped_text() nil end
+
+    # Delimit the link text with markers to replace later unless
+    # the word is escaped. In that case, just return the link text
+    def mask(content) escaped_text || pre_mask + link_text + post_mask end
+
+    def regexp() Regexp.new(pre_mask + '(.*)?' + post_mask) end
+
+    def revert(content) content.sub!(regexp, text) end
+
+    # Do not keep this chunk if it is escaped.
+    # Otherwise, pass the link procedure a page_name and link_text and
+    # get back a string of HTML to replace the mask with.
+    def unmask(content)
+      return nil if escaped_text
+      return self if content.sub!(regexp) { |match| content.page_link(page_name, $1) }
+    end
+  end
+
+  # This chunk matches a WikiWord. WikiWords can be escaped
+  # by prepending a '\'. When this is the case, the +escaped_text+
+  # method will return the WikiWord instead of the usual +nil+.
+  # The +page_name+ method returns the matched WikiWord.
+  class Word < WikiLink
+    def self.pattern
+      Regexp.new('(\\\\)?(' + WikiWords::WIKI_WORD_PATTERN + ')\b', 0, "utf-8")
+    end
+
+    attr_reader :page_name
+
+    def initialize(match_data)
+      super(match_data)
+      @escape = match_data[1]
+      @page_name = match_data[2]
+    end
+
+    def escaped_text() (@escape.nil? ? nil : page_name) end
+    def link_text() WikiWords.separate(page_name) end	
+  end
+
+  # This chunk handles [[bracketted wiki words]] and 
+  # [[AliasedWords|aliased wiki words]]. The first part of an
+  # aliased wiki word must be a WikiWord. If the WikiWord
+  # is aliased, the +link_text+ field will contain the
+  # alias, otherwise +link_text+ will contain the entire
+  # contents within the double brackets.
+  #
+  # NOTE: This chunk must be tested before WikiWord since
+  #       a WikiWords can be a substring of a WikiLink. 
+  class Link < WikiLink
+    def self.pattern() /\[\[([^\]]+)\]\]/ end
+    ALIASED_LINK_PATTERN= Regexp.new('^(.*)?\|(.*)$', 0, "utf-8")
+
+    attr_reader :page_name, :link_text
+
+    def initialize(match_data)
+      super(match_data)
+
+	  # If the like is aliased, set the page name to the first bit
+	  # and the link text to the second, otherwise set both to the
+	  # contents of the double brackets.
+      if match_data[1] =~ ALIASED_LINK_PATTERN
+        @page_name, @link_text = $1, $2
+      else
+        @page_name, @link_text = match_data[1], match_data[1]
+      end
+    end
+  end
+end

data/app/models/page.rb

@@ -0,0 +1,86 @@
+require "date"
+require "page_lock"
+require "revision"
+require "wiki_words"
+require "chunks/wiki"
+
+class Page
+  include PageLock
+
+  CONTINOUS_REVISION_PERIOD = 30 * 60 # 30 minutes
+
+  attr_reader :name, :revisions, :web
+  
+  def initialize(web, name, content, created_at, author)
+    @web, @name, @revisions = web, name, []
+    revise(content, created_at, author)
+  end
+
+  def revise(content, created_at, author)
+    if !@revisions.empty? && continous_revision?(created_at, author)
+      @revisions.last.created_at = Time.now
+      @revisions.last.content    = content
+      @revisions.last.clear_display_cache
+    else
+      @revisions << Revision.new(self, @revisions.length, content, created_at, author)
+    end
+    
+    web.refresh_pages_with_references(name) if @revisions.length == 1
+  end
+  
+  def rollback(revision_number, created_at, author_ip = nil)
+    roll_back_revision = @revisions[revision_number].dup
+    revise(roll_back_revision.content, created_at, Author.new(roll_back_revision.author, author_ip))
+  end
+  
+  def revisions?
+    revisions.length > 1
+  end
+  
+  def revised_on
+    created_on
+  end
+  
+  def pretty_revised_on
+    DateTime.new(revised_on.year, revised_on.mon, revised_on.day).strftime "%B %e, %Y" 
+  end
+  
+  def in_category?(cat)
+    cat.nil? || cat.empty? || categories.include?(cat)
+  end
+
+  def categories
+    display_content.find_chunks(Category).map { |cat| cat.list }.flatten
+  end
+  
+  def authors
+    revisions.collect { |rev| rev.author }
+  end
+
+  def references
+    web.select.pages_that_reference(name)
+  end
+
+  # Returns the original wiki-word name as separate words, so "MyPage" becomes "My Page".
+  def plain_name
+    WikiWords.separate(name, web.brackets_only)
+  end
+
+  def link(options = {})
+    web.make_link(name, nil, options)
+  end
+  
+  def author_link(options = {})
+    web.make_link(author, nil, options)
+  end
+  
+  private
+    def continous_revision?(created_at, author)
+      @revisions.last.author == author && @revisions.last.created_at + CONTINOUS_REVISION_PERIOD > created_at
+    end
+  
+    # Forward method calls to the current revision, so the page responds to all revision calls
+    def method_missing(method_symbol)
+      revisions.last.send(method_symbol)
+    end
+end