Soks 0.0.7 → 1.0.0

data/LICENSE.txt

@@ -62,3 +62,5 @@ GPL (see the file GPL), or the conditions below:
      WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
      PURPOSE.
 </pre>
+
+Tag: Include this page in the distribution

data/README.txt

@@ -63,15 +63,16 @@ I suspect there are many, as befits its version number.  In particular it has:
 * Insert page commands are not inhibited by notextile, pre or code tags
 * Does not permit browsers to cache pages
 * Not user friendly in the way it handles simultaneous edits of a page (last person to save wins)
-* Some bugs in layout and formatting of text.
-* RSS feed does not completely validate
 
 See http://www.soks.org/wiki/KnownBugs for details.
 
 h2. RELEASES
 
+# 2005 July 24 - soks-1.0.0 - Sixth public release (beta)
 # 2005 Mar 21 - soks-0.0.7 - Fifth public release (alpha)
 # 2005 Mar 15 - soks-0.0.6 - Fourth public release (alpha)
 # 2005 Feb 12 - soks-0.0.5 - Third public release (alpha)
 # 2005 Jan 24 - soks-0.0.4 - Second public release  (alpha)
 # 2005 Jan 11 - soks-0.0.2 - First public release (alpha)
+
+Tag: Include this page in the distribution

data/TODO.txt

@@ -0,0 +1,31 @@
+h1. TODO
+
+h2. PUNCTUATION
+# Make sure autolink works with all punctuation
+# Make the page urls ignore punctuation
+# Refactor so that urls all created in single method
+# Make sure that input fields are correctly escaped
+
+h2. FEATURES
+# Seb's attachment fix
+# Page count automatic summaries
+
+h2. RECENT CHANGES
+# Fix changes view (and associated recent changes view) to deal with revision merges and deletes
+# Alter Recent Changes to only merge change runs if they happen with X (12?) hours of each other?)
+
+h2. RSS
+# Check order of rss on new templates
+# Make sure that default template doesn't require authentication for new rss feeds
+# Make the recent changes feed put the name and time of changes
+
+h2. SPEED
+# Profile
+# Allow caches to be saved to disk and re-loaded
+## Pages
+## Links
+## Redcloth
+
+h2. HELPERS
+# Check mail import
+# Check rss feed import

data/bin/soks-create-wiki.rb

@@ -181,5 +181,4 @@ if start && File.exists?( script )
 	end
 	puts "Starting #{destination} on #{url}"
 	require script
-	StartSoks::start
 end

data/lib/authenticators.rb

@@ -6,11 +6,31 @@ require 'base64'
 module WEBrick
   module HTTPAuth
 		
+		module SoksUserCookie
+
+			def username_from_cookie(request)
+				cookie = request.cookies.find { |cookie| cookie.name == 'username' }
+				return cookie.value if cookie
+				return nil
+			end		   
+
+			def add_cookie(request,response)
+				cookie = WEBrick::Cookie.new( 'username', request.user )
+				cookie.path = '/'
+				cookie.expires = Time.now + ( 60 * 60 * 24 * 180 ) # Expires in 180 days
+				response.cookies << cookie
+			end
+			
+		end
+		
 		class NoAuthenticationRequired
+			include SoksUserCookie
 			
 			def authenticate(req, res)
-				req.user = req.meta_vars["HTTP_X_FORWARDED_FOR"] || req.meta_vars["REMOTE_ADDR"]
+				req.user = username_from_cookie(req) || req.meta_vars["HTTP_X_FORWARDED_FOR"] || req.meta_vars["REMOTE_ADDR"]
 			end
+			
+
 		end
 		
 		class NotPermitted
@@ -22,14 +42,14 @@ module WEBrick
 		end
 	
 		class AskForUserName
-			
 			include WEBrick::HTTPAuth::Authenticator
+			include SoksUserCookie
 			
 			AuthScheme = "Basic"
 	
-			def  initialize( realm = "editing" )
+			def initialize( realm = "editing" )
 				config = { :UserDB => "nodb" , :Realm => realm }
-		      check_init(config)
+		      	check_init(config)
 				@config = Config::BasicAuth.dup.update(config)
 		   end
 
@@ -44,16 +64,20 @@ module WEBrick
 		     end
 		     info("%s: authentication succeeded.", userid)
 		     req.user = userid
+		     add_cookie(req,res)
+		     userid
 		   end
 
 		   def challenge(req, res)
 		     res[@response_field] = "#{@auth_scheme} realm=\"#{@realm}\""
 		     raise @auth_exception
 		   end
+
 		end
 		
     class SiteWidePassword
       include Authenticator
+	  include SoksUserCookie
 
       AuthScheme = "Basic"
 
@@ -83,6 +107,8 @@ module WEBrick
         end
         info("%s: authentication succeeded.", userid)
         req.user = userid
+       	add_cookie(req,res)
+		userid
       end
 
       def challenge(req, res)

data/lib/helpers/counter-helpers.rb

@@ -0,0 +1,132 @@
+class CounterObject
+	
+	attr_reader :total,:start_time
+	
+	def initialize( show_top = 20 )
+		@show_top = show_top
+		@counts = {}
+		@total, @start_time = 0, Time.now
+	end
+	
+	def count( thing_to_count )
+		@counts[thing_to_count] = ( @counts[thing_to_count] || 0 ) + 1
+		@total += 1
+	end
+	
+	def each
+		running_total, displayed = 0, 0
+		@counts.sort_by { |thing,count| count }.reverse_each do |thing,count|
+			break if @show_top && ( displayed >= @show_top )
+			displayed += 1
+			running_total += count
+			yield thing, count
+		end
+		if @show_top && (@show_top < @counts.size)
+			yield "#{@counts.size - @show_top} others", @total-running_total
+		end
+		yield "*Total*", "*#{@total}*"
+	end
+	
+	def [](thing)
+		@counts[thing]
+	end
+	
+	def empty?
+		@counts.empty?
+	end
+
+end
+
+class ViewCountHelper
+	
+	attr_reader :counts
+	
+	def initialize( wiki, views_to_count = [ 'view' ], page_name = 'Popular Pages', update_page_every = :hour, show_top = 20, cache_name = 'viewcount' )
+		@wiki = wiki
+		@counts = wiki.load_cache(cache_name) || CounterObject.new(show_top)
+		@views_to_count, @page_name = views_to_count, page_name
+		@wiki.watch_for(:page_viewed) { |event,page,view,author| count page, view, author }
+		@wiki.watch_for(update_page_every) { render_count_page }
+		@wiki.watch_for(:shutdown) { wiki.save_cache(cache_name,@counts)}
+	end
+	
+	def count( page, view, author )
+		return unless should_count?( page, view, author )
+		@counts.count(count_key( page, view, author ))
+	end
+	
+	def should_count?( page, view, author )
+		@views_to_count.include?( view.downcase )
+	end
+	
+	def count_key( page, view, author )
+		page.name
+	end
+	
+	def render_count_page
+		content = "h1. #{@page_name}\n\n"
+		content << "Count since #{@counts.start_time}. Updated on #{Time.now}\n\n"
+		@counts.each do |page,count|
+			content << "| #{page} | #{count} |\n"
+		end
+		@wiki.revise( @page_name, content, 'AutomaticCounter' )
+	end
+	
+end
+
+class ViewerCountHelper < ViewCountHelper
+	
+	def initialize( wiki, views_to_count = [ 'view' ], page_name = 'Prolific Viewers', update_page_every = :hour, show_top = 20, cache_name = 'viewercount' ) 
+		super( wiki, views_to_count, page_name, update_page_every, show_top, cache_name )
+	end
+	
+	def count_key( page, view, author )
+		author
+	end
+end
+
+class AuthorCountHelper
+	
+	attr_reader :counts
+	
+	def initialize( wiki, page_name = 'Principal Authors', update_page_every = :hour, show_top = 20, cache_name = 'authorcount' )
+		@wiki = wiki
+		@counts = wiki.load_cache(cache_name) || CounterObject.new(show_top) 
+		count_from_scratch if @counts.empty?
+		@page_name =  page_name
+		@wiki.watch_for(:page_revised) { |event,page,revision| count page, revision }
+		@wiki.watch_for(update_page_every) { render_count_page }
+		@wiki.watch_for(:shutdown) { wiki.save_cache(cache_name,@counts)}
+	end
+	
+	def count_from_scratch
+		@wiki.each do |pagename,page|
+			page.revisions.each do |revision|
+				count( page, revision )
+			end
+		end
+	end
+	
+	def count( page, revision )
+		return unless should_count?( page, revision )
+		@counts.count(count_key( page, revision ))
+	end
+	
+	def should_count?( page, revision )
+		revision.author !~ /^Automatic/
+	end
+	
+	def count_key( page, revision )
+		revision.author
+	end
+	
+	def render_count_page
+		content = "h1. #{@page_name}\n\n"
+		content << "Count since #{@counts.start_time}. Updated on #{Time.now}\n\n"
+		@counts.each do |page,count|
+			content << "| #{page} | #{count} |\n"
+		end
+		@wiki.revise( @page_name, content, 'AutomaticCounter' )
+	end
+	
+end

data/lib/helpers/default-helpers.rb

@@ -14,13 +14,15 @@ class AutomaticUpdateCrossLinks
 	def new_page( page )
 		return if title_banned? page.name
 		@view.rollingmatch[ page.name ] = page 
-		titleregex = Regexp.new( page.name, Regexp::IGNORECASE )
-		@wiki.each { |name, linkedpage | 
-			if linkedpage.textile =~ titleregex
-		   		@view.refresh_redcloth( linkedpage )
-		   		linkedpage.inserted_into.each { |insert| @view.refresh_redcloth( insert ) }
-		   	end 
-		}
+		titleregex = Regexp.new( Regexp.escape(page.name), Regexp::IGNORECASE )
+		# Refresh any page that might mention the title of the new page
+		@wiki.each do |name, linkedpage |
+			next if linkedpage.is_a? UploadPage
+			next unless linkedpage.textile =~ titleregex
+			@view.refresh_redcloth( linkedpage )
+			# Pages can be inserted into other pages, so need to refresh those as well
+			linkedpage.inserted_into.each { |insert| @view.refresh_redcloth( insert ) }
+		end
 	end
 	
 	def delete_page( page )
@@ -29,178 +31,196 @@ class AutomaticUpdateCrossLinks
 	end
 	
 	def page_revised( page )
-		page.inserted_into.each { |including_page| 
-			@view.refresh_redcloth( including_page ) 
-		}
+		page.inserted_into.each { |including_page| @view.refresh_redcloth( including_page ) }
 	end
 	
 	def update_all_pages
-		@wiki.each { |pagename, page| @view.rollingmatch[ page.name ] = page unless title_banned?( page.name )}
-		@wiki.each { |pagename, page| @view.refresh_redcloth( page ) }
+		@wiki.each do |pagename, page| 
+			@view.rollingmatch[ page.name ] = page unless title_banned?( page.name )
+			@view.links.links[ page ] = page.links_from
+		end
+		# Not needed now, because notife d
+		#@wiki.each do |pagename, page| 
+		#	@view.redcloth( page )
+		#end
 	end
 	
 	def title_banned?( title )
 		@banned_titles.include? title
-	end
-	
+	end	
 end
 
 class AutomaticSummary
 	
 	DEFAULT_SETTINGS = {
-	 	:regexp_for_title => /.*/, # These six regexps act as an AND, with the exclude three acting as NOT their contents
-		:regexp_for_author => nil, 
-		:regexp_for_content => nil,
-		:regexp_to_exclude_title => nil,
-		:regexp_to_exclude_author => nil,
-		:regexp_to_exclude_content => nil,
 		:max_pages_to_show => nil,
-		:pagename => 'Summary',
+		:description => 'This summary was created automatically',
 		:author => 'AutomaticSummary',
-		:lines_to_include => nil, # Or pass a block
-		:only_new_pages => false,
+		:lines_to_include => 10,
 		:sort_pages_by => :created_on, # Could be :revised_on or :score or :name or :name_for_index, or :author
 		:reverse_sort => false,
-		:include_metadata => false, # Includes author and time in summary
-		:summarise_revisions => false, # If true, then can contain several revisions for same page
+		:event => :page_created, # Only summarises new pages. :page_revised would summarise changed pages
 		:remove_deleted_pages => true, # If false will keep references to deleted pages
-		:merge_revisions => false, # If true, repeats with the same author will be merged
+		:summarise_revisions => false, # If true will list revisions rather than pages
+		:merge_revisions_within => false, # If set to a number, repeats with the same author within that many seconds will be merged
 	}
 
-	attr_reader :settings, :pages_in_summary
+	attr_reader :name, :settings, :pages_in_summary
 
-	def initialize( wiki, settings = {}, &renderer )
-		@wiki, @settings, @renderer = wiki, DEFAULT_SETTINGS.merge( settings ), renderer
-		setup_list
-		scan_for_pages_to_summarise_in wiki
-		render_summary
+	def initialize( wiki, name, settings = {}, &decision )
+		@wiki, @name, @decision = wiki, name, decision
+		@settings = DEFAULT_SETTINGS.merge( settings )
+		@pages_in_summary = FiniteUniqueList.new( @settings[:max_pages_to_show], @settings[:reverse_sort], @settings[:sort_pages_by] )
+		if @settings[:summarise_revisions]
+			scan_revisions_allready_in_wiki
+		else	
+			scan_pages_allready_in_wiki
+		end
 		start_watching wiki
 	end
+
+	private
 	
-	def check_whether_to_add_page( page, revision )
-		return unless summarise?( page )
-		remove_previous_revisions( page, revision ) if @settings[:merge_revisions]
-		@pages_in_summary.add( @settings[:summarise_revisions] ? revision : page ) 
-		render_summary
+	def start_watching( wiki )
+		wiki.watch_for( @settings[:event] ) do |event, page, revision| 
+			check_whether_to_add_page( @settings[:summarise_revisions] ? revision : page ) 
+		end
+		return unless @settings[:remove_deleted_pages]
+		wiki.watch_for( :page_deleted ) do |event, page, revision| 
+			check_whether_to_remove_page( @settings[:summarise_revisions] ? revision : page )
+		end
 	end
 	
-	def check_whether_to_remove_page( page, revision )
-		return unless @settings[:remove_deleted_pages]
+	def check_whether_to_add_page( page )	
 		return unless summarise?( page )
-		return unless @pages_in_summary.remove( @settings[:summarise_revisions] ? revision : page )
-		render_summary
+		remove_previous_revisions( page )
+		@pages_in_summary.add( page ) 
+		render_summary_page
 	end
 	
-	private
+	def check_whether_to_remove_page( page ) 
+		render_summary_page if @pages_in_summary.remove( page )
+	end
 	
 	def summarise?( page )
 		return false if page.name == @settings[:pagename]
-		return false if @settings[:regexp_for_title] && page.name !~ @settings[:regexp_for_title] 
-		return false if @settings[:regexp_for_author] && page.author !~ @settings[:regexp_for_author] 
-		return false if @settings[:regexp_for_content] && page.content !~ @settings[:regexp_for_content]
-		return false if @settings[:regexp_to_exclude_title] && page.name =~ @settings[:regexp_to_exclude_title] 
-		return false if @settings[:regexp_to_exclude_author] && page.author =~ @settings[:regexp_to_exclude_author] 
-		return false if @settings[:regexp_to_exclude_content] && page.content =~ @settings[:regexp_to_exclude_content]
-		return true 
-	end
-	
-	def scan_for_pages_to_summarise_in( wiki )
-		wiki.each( @settings[:remove_deleted_pages] ) do |name,page| 
-			if @settings[:summarise_revisions]
-				scan_for_revisions_to_summarise_in( page )
-			else
-				next unless summarise? page
-				@pages_in_summary.add page
-			end
+		@decision.call( page )
+	end
+	
+	def scan_pages_allready_in_wiki		
+		@wiki.each( @settings[:remove_deleted_pages] ) do |name,page| 
+			next unless summarise?(page)
+			@pages_in_summary.add(page)
 		end
+		render_summary_page
 	end
 	
-	def scan_for_revisions_to_summarise_in( page )
-		page.revisions.each do |revision| 
-			next unless summarise? revision
-			remove_previous_revisions( page, revision ) if @settings[:merge_revisions]
-			@pages_in_summary.add revision 
+	def scan_revisions_allready_in_wiki
+		@wiki.each( @settings[:remove_deleted_pages] ) do |name,page|
+			page.revisions.each do |revision| 
+				next unless summarise? revision
+				remove_previous_revisions( revision )
+				@pages_in_summary.add revision
+			end
 		end
+		render_summary_page
 	end
 	
-	def remove_previous_revisions( page, revision )
+	def remove_previous_revisions( revision )
+		return unless @settings[:summarise_revisions]
+		return unless @settings[:merge_revisions_within]
 		revision.number.downto(0) do |previous_number|
-			previous_revision = page.revisions.at( previous_number )
+			previous_revision = revision.revisions.at( previous_number )
 			break unless previous_revision.author == revision.author
+			break unless (revision.revised_on - previous_revision.revised_on) < @settings[:merge_revisions_within]
 			@pages_in_summary.remove( previous_revision )
 		end
 	end
 	
+	# These methods relate to how the summary is shown.
+	
+	def render_summary_page
+		@wiki.page( name ).content =~ /(.*?<automaticsummary.*?>).*?(<\/automaticsummary>.*)/mi
+		@wiki.revise( name, ($1 || new_top) + "\n\n" + render_summary + "\n\n" + ($2 || new_tail), @settings[:author] )
+	end
+	
 	def render_summary
-		@wiki.page( @settings[:pagename] ).textile =~ /(.*?<automaticsummary>).*?(<\/automaticsummary>.*)/mi
-		top = $1 || "h2. #{@settings[:pagename]}\n\np{font-size: x-small;}. #{@settings[:pagename]} was created automatically from pages whose title matches ==#{@settings[:regexp_for_title].inspect}==.\n\n<automaticsummary>"
-		tail = $2 || "</automaticsummary>"
-		@wiki.revise( @settings[:pagename], top + render_list + tail , @settings[:author] )
-	end
-	
-	def render_list
-		content = "\n\n"
-		if @pages_in_summary.empty?
-			content << "No pages found to summarise"
-		elsif @renderer
-			@pages_in_summary.each { |page| content << @renderer.call(page)  }
-		elsif @settings[:lines_to_include]
-			@pages_in_summary.each { |page| content << render_page(page)  }
+		return "No pages found to summarise" if @pages_in_summary.empty?
+		@pages_in_summary.map { |page| render_summary_of_page(page)  }.to_s
+	end
+	
+	def render_summary_of_page( page )
+		content = 	"<div class='subpage'>"
+		content << 	"[[ #{page.name} ]]<br />\n\n"
+		if page.is_a? UploadPage
+			content << "[[ insert #{page.name} ]]"
 		else
-			@pages_in_summary.each { |page| content << render_link_to(page) }
+			content << page.content.first_lines( @settings[:lines_to_include] ).close_unmatched_html
 		end
-		content << "\n\n"
+		content << "\n\np(more). [[(more) => #{page.name}]]\n\n</div>\n"
 	end
-	
-	def render_page( page )
-		"<div class='subpage'>\n[[ #{page.name} ]] #{ @settings[:include_metadata] ? render_meta_data( page ) : "" }<br />\n\n#{page.textile.first_lines( @settings[:lines_to_include] ).close_unmatched_html}\n\np(more). [[(more) => #{page.name}]]\n\n</div>\n" 
+
+	def new_top
+"h2. #{name}
+
+p{font-size: x-small;}. #{@settings[:description]}
+
+<automaticsummary warning='DO NOT EDIT between these automatic summary tags, anything you write may be overwritten without warning'>
+"	
 	end
 	
-	def render_link_to( page )
-		"* [[ #{page.name} ]] #{ @settings[:include_metadata] ? render_meta_data( page ) : "" }\n"
+	def new_tail
+		"</automaticsummary>"
 	end
 	
-	def render_meta_data( page )
-		"revised on #{page.revised_on.strftime('%Y %b %d %H:%M')} by #{page.author}"
-	end
+
+end
+
+class AutomaticList < AutomaticSummary
 	
-	def setup_list
-		@pages_in_summary = FiniteUniqueList.new( @settings[:max_pages_to_show], @settings[:reverse_sort], @settings[:sort_pages_by] )
+	def render_summary
+		@pages_in_summary.map { |page| render_list_item(page) }.to_s
 	end
 	
-	def start_watching( wiki )
-		wiki.watch_for( @settings[:only_new_pages] == true ? :page_created : :page_revised ) { |event, page, revision| check_whether_to_add_page( page, revision ) }
-		wiki.watch_for( :page_deleted ) { |event, page, revision| check_whether_to_remove_page( page, revision ) } if @settings[:remove_deleted_pages]
+	def render_list_item( page )
+		"* [[ #{page.name} ]]\n"
 	end
 	
 end
 
+class AutomaticDetailedList < AutomaticList
+	
+	def render_list_item( page )
+		"* [[ #{page.name} ]] revised on #{page.revised_on.strftime('%Y %b %d %H:%M')} by #{page.author}\n"
+	end
+
+end
+
 class AutomaticRecentChanges < AutomaticSummary
 	
-	def initialize( wiki, changes = 200, title_regexp = /.*/, pagename = "Recent Changes to This Site", author = "AutomaticRecentChanges", exclude_automatic_helpers = true, merge_revisions = true )
-			super( wiki, { 	:pagename => pagename,
-							:regexp_for_title => title_regexp,
-							:regexp_to_exclude_author => exclude_automatic_helpers && /^Automatic/i,
-							:max_pages_to_show => changes,
-							:author => author,
-							:only_new_pages => false,
-							:sort_pages_by => :revised_on,
-							:summarise_revisions => true,
-							:reverse_sort => true,
-							:remove_deleted_pages => false,
-							:merge_revisions => merge_revisions,
-						} )		
-	end
-	
-	def render_list
+	def initialize( wiki, changes = 200, pagename = "Recent changes to this site", author = "AutomaticRecentChanges", exclude_automatic_helpers = true, merge_revisions_within = 60*60*12 )
+		super( wiki, pagename, 	:summarise_revisions => true,
+								:max_pages_to_show => changes,
+							 	:author => author,
+								:sort_pages_by => :revised_on,
+								:event => :page_revised,
+								:reverse_sort => true,
+								:remove_deleted_pages => false,
+								:merge_revisions_within => merge_revisions_within ) do |revision|
+									exclude_automatic_helpers ? revision.author !~ /^Automatic/i : true
+								end
+		wiki.watch_for( :day ) {  render_summary_page }		
+	end
+	
+	def render_summary
 		content = "<div class='recentchanges'>\n\nh2. Today\n\n"
 		previous_time = Time.now
 		@pages_in_summary.each do |revision| 
 			unless revision.revised_on.same_day?( previous_time )
-				content << "\nh2. #{revision.revised_on.strftime('%a %d %b %Y')}\n\n"
+				content << "\nh2. #{revision.revised_on.relative_day}\n\n"
 				previous_time = revision.revised_on
 			end
-			content << "* #{revision.revised_on.strftime('%H:%M')} - [[#{revision.name}]] revised by #{revision.author}\n"	
+			content << "* #{revision.revised_on.strftime('%H:%M')} - [[#{revision.name}]] revised by #{revision.author} ([[changes => /revision/#{revision.name}?time=#{revision.created_on.to_i}]])\n"	
 		end
 		content << "\n\n</div>"
 	end
@@ -210,55 +230,52 @@ end
 class AutomaticOnePageIndex
 	
 	def initialize( wiki, pagename = "Site Index", author = "AutomaticIndex"  )
-		AutomaticSummary.new( wiki, { 	:pagename => pagename,
-										:regexp_to_exclude_title => /#{Regexp.escape(pagename)}/i,
-										:author => author,
-										:only_new_pages => true,
-										:sort_pages_by => :name_for_index,
-										} )
+		AutomaticList.new( wiki, pagename, :author => author, :sort_pages_by => :name_for_index ) do |page|
+			page.name !~ /#{Regexp.escape(pagename)}/io
+		end
 	end	
 	
 end
 
 class AutomaticMultiPageIndex
-	
+ 	
 	def initialize( wiki, pageroot = "Site Index", author = "AutomaticIndex"  )
-		content = "h1. #{pageroot}\n\n"
-		('A'..'Z').each do |letter|
-			AutomaticSummary.new( wiki, {  	:regexp_for_title => /^#{letter}.*/i,
-											:pagename => "#{pageroot} #{letter}.",
-											:regexp_to_exclude_title => /^#{Regexp.escape(pageroot)} ([a-z]|Other)\./i,
-											:author => author,
-											:only_new_pages => true,
-											:sort_pages_by => :name_for_index,
-											} )
-			content << "* #{pageroot} #{letter}.\n"
-		end
-		AutomaticSummary.new( wiki, {  	:regexp_for_title => /^[^A-Za-z].*/,
-										:pagename => "#{pageroot} Other.",
-										:regexp_to_exclude_title => /^#{Regexp.escape(pageroot)} ([a-z]|Other)\./i,
-										:author => author,
-										:only_new_pages => true,
-										:sort_pages_by => :name_for_index,
-										} )
-	 	content << "* #{pageroot} Other.\n"
-		wiki.revise( pageroot, content, author )
-	end	
-	
-end
-
+ 		('A'..'Z').each do |letter|
+ 			AutomaticList.new( wiki, "#{pageroot} #{letter}.", :author => author, :sort_pages_by => :name_for_index ) do |page|
+ 				if page.name =~ /^#{Regexp.escape(pageroot)} ([a-z]|Other)\./i
+ 					false
+ 				else
+ 					page.name =~ /^#{letter}.*/i
+ 				end
+ 			end
+ 		end
+ 	
+ 		AutomaticList.new( wiki, "#{pageroot} Other.", :author => author, :sort_pages_by => :name_for_index ) do |page|
+ 			if page.name =~ /^#{Regexp.escape(pageroot)} ([a-z]|Other)\./i
+ 				false
+ 			else
+ 				page.name =~  /^[^A-Za-z].*/i
+ 			end
+ 		end
+ 	
+ 		AutomaticList.new( wiki, pageroot, :author => author, :sort_pages_by => :name_for_index ) do |page|
+ 			page.name =~ /^#{Regexp.escape(pageroot)} ([a-z]|Other)\./i
+ 		end
+ 	end	
+ end
+ 
 class AutomaticCalendar
 	
 	attr_reader :month_pagename, :day_pagename
 	
 	def initialize( wiki, month_pagename = '%Y %b', day_pagename = '%Y %b %d', author = "AutomaticCalendar" )
 		@wiki, @month_pagename, @day_pagename, @author = wiki, month_pagename, day_pagename, author
-		Thread.new do
-			loop do
-				Time.now.month.upto( Time.now.month+12 ) { |m| render_month( m ) }
-				sleep(60*60*24)
-			end 
-		end
+		render_coming_year
+		@wiki.watch_for(:month) { render_coming_year }
+	end
+	
+	def render_coming_year
+		Time.now.month.upto( Time.now.month+12 ) { |m| render_month( m ) }
 	end
 	
 	def render_month( month )
@@ -278,7 +295,7 @@ class AutomaticCalendar
 		end
 		day.wday.upto( 5 ) { content << "| . " }
 		content << "|\n"
-		content << "\n\n< #{month_pagename( month-1 )}  #{month_pagename( month+1 )} >\n"	
+		content << "\n\n#{month_pagename( month-1 )} #{month_pagename( month+1 )} \n"	
 		content << "\n</div>"	
 	end
 	
@@ -308,12 +325,7 @@ class AutomaticUpcomingEvents
 	def initialize( wiki, calendar, days_passed = 0, days_future = 7, pagename = 'Upcoming Events', author = "AutomaticUpcomingEvents" )
 		@wiki, @calendar, @days_passed, @days__future, @pagename, @author = wiki, calendar, days_passed, days_future, pagename, author
 		@wiki.watch_for( :page_revised ) { |event, page| page_revised( page ) }
-		Thread.new do
-			loop do
-				render_upcoming_events
-				sleep(60*60)
-			end 
-		end
+		@wiki.watch_for( :day ) { render_upcoming_events }
 	end
 
 	def page_revised( page )
@@ -324,7 +336,7 @@ class AutomaticUpcomingEvents
 		content = "<div class='upcomingevents'>\n\n"
 		Time.now.day.upto( Time.now.day+7 ) do |day|
 			time =  @calendar.time_for( Time.now.month, day )
-			content << "| [[ #{relative_day( time ) } => #{@calendar.day_pagename( time )} ]] |"
+			content << "| [[ #{time.relative_day} => #{@calendar.day_pagename( time )} ]] |"
 			content << (@wiki.exists?( @calendar.day_pagename(time) ) ? render_event( @calendar.day_pagename( time ) ) : "&nbsp; |\n")	
 		end
 		content << "\n\np(more). [[(more) => #{@calendar.month_pagename}]]\n\n"
@@ -332,17 +344,6 @@ class AutomaticUpcomingEvents
 		@wiki.revise( "Upcoming Events", content , "AutomaticCalendar" ) 
 	end
 	
-	def relative_day( date )
-		case ( (date - @calendar.time_for( Time.now.month, Time.now.day ) ) / ( 60 * 60 * 24 ) ) # Days difference
-		when -7..-2	; 	date.strftime('Last %A')
-		when -1 		; 	"Yesterday"
-		when 0 		; 	"Today"
-		when 1 		; 	"Tomorrow"
-		when 2..7	;	date.strftime('%A')
-		else			; 	date.strftime('%A %d')
-		end
-	end
-	
 	def render_event( name )
 		page = @wiki.page( name )
 		headings = page.textile.select { |line| line =~ /^h\d\./ }