Soks 0.0.7 → 1.0.0

data/lib/helpers/mail2wiki-helper.rb

@@ -3,7 +3,7 @@ require 'net/imap'
 # From Dave Burt on comp.lang.ruby
 class String
  def from_quoted_printable
-   self.gsub(/\r\n/, "\n").unpack("M").first
+   self.gsub(/\r\n/, "\n").gsub(/=(?![\dA-F]{2})/,'=3D').unpack("M").first
  end
 end
 
@@ -14,20 +14,16 @@ class Message
 	def initialize( imap, message_id )
 		@imap, @message_id = imap, message_id
 		envelope = @imap.fetch( @message_id, 'ENVELOPE' ).first.attr['ENVELOPE']
-		@subject = envelope['subject']
-		@sender_name = envelope['from'].first['name']
+		@subject = envelope['subject'].gsub(/^(Fw|Re):?/i,'').strip
+		@sender_name = envelope['from'].first['name'].gsub(/@/,' at ')
 		@date = envelope['date']
-		@sender_email = envelope['from'].first['mailbox'] + '@' + envelope['from'].first['host']
+		@sender_email = envelope['from'].first['mailbox'] + ' at ' + envelope['from'].first['host']
+		@sender_name = @sender_email unless @sender_name && @sender_name.size > 1
 		@text = plain_text_content_from_message( message_id )
 	end
 	
 	def plain_text_content_from_message( id )
-		text = @imap.fetch( id, 'BODY[1]' ).first.attr['BODY[1]'].from_quoted_printable
-		text
-	end
-	
-	def textile
-		text.gsub(/[\*-]{2,}/,'').gsub(/([^\n])\n([^\n])/,'\1\2').gsub(/^[ \t]+/,'')
+		@imap.fetch( id, 'BODY[1]' ).first.attr['BODY[1]'].from_quoted_printable
 	end
 
 end
@@ -38,31 +34,29 @@ class Mail2WikiHelper
 		:server => 'imap.hermes.cam.ac.uk',
 		:username => 'tamc2',
 		:password => 'missing_a_password',
-		:mailbox => 'mcr notices',
-		:check_period => 600, # Seconds
+		:mailbox => 'test',
+		:check_event => :hour,
 		:subject_regexp => /.*/,
+		:keyword => 'PutInWiki'
 	}
 	
 	def initialize( wiki, settings = {} )
 		@settings = DEFAULT_SETTINGS.merge( settings )
 		@wiki = wiki
 		check_mailbox
-		Thread.new do 
-			loop do
-				sleep @settings[:check_period ]
-				check_mailbox
-			end
-		end
+		@wiki.watch_for(@settings[:check_event]) { check_mailbox }
 	end
 	
 	private
 	
 	def check_mailbox
+		$LOG.info "Checking #{@settings[:mailbox]} on #{@settings[:server]}"
 		login
 		select_mailbox
 		new_messages_for_wiki do |message_id|
 			this_message = Message.new( @imap, message_id )
 			if this_message.subject =~ @settings[:subject_regexp]
+				$LOG.info "Adding '#{this_message.subject}' to wiki"
 				add_message_to_wiki( this_message ) 
 				mark_as_added( message_id )
 			end
@@ -78,8 +72,10 @@ class Mail2WikiHelper
 			text = current_page.textile
 		end
 		text << "\n\n"
-		text << "#{message.date} from #{message.sender_name} #{message.sender_email}\n"
-		text << message.text 		
+		text << "*Copied from Email on #{message.date} from #{message.sender_name} (#{message.sender_email})*\n\n"
+		text << "<pre>\n"
+		text << message.text
+		text << "\n</pre>\n"
 		@wiki.revise(message.subject, text, message.sender_name )
 	end
 	
@@ -98,11 +94,11 @@ class Mail2WikiHelper
 	end
 	
 	def new_messages_for_wiki 
-		@imap.search('UNKEYWORD PutInWiki').each { |id| yield id } 		
+		@imap.search("UNKEYWORD #{@settings[:keyword]}").each { |id| yield id } 		
 	end
 	
 	def mark_as_added( id )
-		# @imap.store( id, '+FLAGS', ['PutInWiki'] )
+		@imap.store( id, '+FLAGS', [@settings[:keyword]] )
 	end
 	
 end

data/lib/helpers/maintenance-helpers.rb

@@ -0,0 +1,149 @@
+class DeleteOldPagesHelper
+	
+	# Default wakes up each day at midnight and wipes all deleted pages more than 100 days old
+	def initialize( wiki, event_to_check_on = :day, age_to_wipe_at = 60*60*24*100 ) 
+		@wiki = wiki
+		@age_to_wipe_at = age_to_wipe_at
+		@wiki.watch_for(event_to_check_on) { check_and_delete_pages }
+	end
+	
+	private
+	
+	def check_and_delete_pages
+		@wiki.each(false) do |name, page|
+			next unless page.deleted?
+			next unless old_enough_to_wipe?( page )
+			$LOG.warn "Permanently wiping #{name} from wiki AND from disk"
+			@wiki.wipe_from_disk( name )
+		end
+	end
+	
+	def old_enough_to_wipe?( page )
+		(Time.now - page.revised_on) > @age_to_wipe_at
+	end
+	
+end
+
+class DeleteOldRevisionsHelper
+	
+	AUTHOR = 'Automatic Revision Remover'
+	
+	# Default wakes up each day at midnight and wipes all revisions more than 100 days old if there are more than 20 revisions in the page
+	def initialize( wiki, event_to_check_on = :day, age_to_wipe_at = 60*60*24*365, maximum_revisions = 20 ) 
+		@wiki = wiki
+		@age_to_wipe_at = age_to_wipe_at
+		@maximum_revisions = maximum_revisions
+		@wiki.watch_for(event_to_check_on) { check_and_delete_revisions }
+	end
+	
+	private
+	
+	def check_and_delete_revisions
+		@wiki.each do |name, page|
+			next unless page.revisions.size > @maximum_revisions
+			next unless old_enough_to_delete?( page.revisions.first )
+			delete_old_revisions_from( page )
+		end
+	end
+	
+	def delete_old_revisions_from( page )
+		page.content_lock.synchronize do
+			delete_revisions_at_or_below = page.revisions.size - @maximum_revisions - 1
+			delete_revisions_at_or_below -= 1 while not old_enough_to_delete? page.revisions[delete_revisions_at_or_below]
+			
+			new_revisions = []
+			new_revisions << Revision.new( 	page, 
+											new_revisions.length, 
+											page.revisions[delete_revisions_at_or_below].content.changes_from(""), 
+											AUTHOR, 
+											page.revisions[delete_revisions_at_or_below].created_on )
+											
+			page.revisions[ (delete_revisions_at_or_below+1)..page.revisions.size].each do |revision|
+				new_revisions << Revision.new( 	page, 
+												new_revisions.length, 
+												revision.changes, 
+												revision.author, 
+												revision.created_on )			
+			end
+			page.revisions = new_revisions
+			@wiki.save_all_revisions( page )
+		end
+	end
+	
+	def old_enough_to_delete?( revision )
+		(Time.now - revision.created_on) > @age_to_wipe_at
+	end
+end
+
+class MergeOldRevisionsHelper
+	
+	# Default wakes up each hour and merges all revisions more than 24 hours old, by the same author, and that are created within an hour of each other
+	def initialize( wiki, event_to_check_on = :day, minimum_age_to_merge = 60*60*24*365, maximum_time_between_revisions_for_merge = 60*60 ) 
+		@wiki = wiki
+		@minimum_age_to_merge = minimum_age_to_merge
+		@maximum_time_between_revisions_for_merge = maximum_time_between_revisions_for_merge
+		@wiki.watch_for(event_to_check_on) { check_for_pages_to_merge }
+	end
+
+	def check_for_pages_to_merge
+		@wiki.each do |name, page|
+			page.content_lock.synchronize do
+				check_revisions_to_merge_on page
+			end
+		end
+	end	
+	
+	def check_revisions_to_merge_on( page )
+		return if page.empty?
+		change_made = false
+		new_revisions = []
+		next_revision = page.revisions.first
+		while next_revision
+			ending_revision = next_revision
+			
+			while can_merge?( next_revision, ending_revision.following_revision )
+				ending_revision = ending_revision.following_revision
+			end
+			 
+			changes = 	if ending_revision == next_revision
+							next_revision.changes
+						else
+							change_made = true
+							ending_revision.content.changes_from( next_revision.previous_content )
+						end
+						
+			new_revisions << Revision.new( 	page, 
+											new_revisions.length, 
+											changes, 
+											ending_revision.author, 
+											ending_revision.created_on )
+											
+			next_revision = ending_revision.following_revision
+		end	
+		if change_made
+			page.revisions = new_revisions
+			@wiki.save_all_revisions( page )
+		end
+	end
+	
+	def can_merge?( revision_a, revision_b )
+		return false unless revision_a && revision_b
+		return false unless same_author?( revision_a, revision_b )
+		return false unless revised_at_a_similar_time?( revision_a, revision_b )
+		return false unless not_to_recent?( revision_a )
+		return false unless not_to_recent?( revision_b )
+		true
+	end
+	
+	def same_author?( a, b )
+		a.author == b.author
+	end
+	
+	def revised_at_a_similar_time?( a, b )
+		(a.revised_on - b.revised_on).abs < @maximum_time_between_revisions_for_merge
+	end
+	
+	def not_to_recent?( a_revision )
+		(Time.now - a_revision.revised_on) > @minimum_age_to_merge
+	end
+end

data/lib/helpers/rss2wiki-helper.rb

@@ -7,19 +7,18 @@ class RSS2WikiHelper
 	DEFAULT_SETTINGS = {
 		:url => 'http://localhost:8000/rss/recent%20changes%20to%20this%20site',
 		:pagename => nil, # If nil, uses channel title,
-		:check_frequency => 1200,
+		:update_on_event => :hour,
 		:author => 'AutomaticRSS2Wiki',
 	}
 	
 	def initialize( wiki, settings = {} )
 		@settings = DEFAULT_SETTINGS.merge( settings )
 		@wiki = wiki
-		Thread.new do
-			loop do
-				update_rss
-				update_wiki
-				sleep @settings[ :check_frequency ]
-			end
+		update_rss
+		update_wiki
+		@wiki.watch_for(@settings[:update_on_event]) do 
+			update_rss
+			update_wiki
 		end
 	end
 	
@@ -36,7 +35,7 @@ class RSS2WikiHelper
 	end
 
 	def update_rss
-		$stderr.puts "Updating feed"
+		$LOG.info "Updating feed"
 		open(@settings[:url]) do |http| 
 			@rss = RSS::Parser.parse( http.read , false) 
 		end

data/lib/soks-model.rb

@@ -2,8 +2,8 @@ require 'thread'
 
 # Revision stores changes as a diff against the more recent content version
 class Revision
-	attr_reader	:number,  :author, :page
-	attr_reader  :changes, :created_on 
+	attr_reader	:number, :author, :page
+	attr_reader :changes, :created_on 
 	alias :revised_on :created_on
 	
 	def initialize( page, number, changes, author, created_on = Time.now )
@@ -13,7 +13,7 @@ class Revision
 	# Recreates the content of the page AFTER this revision had been made.
 	# Done by recursively applying diffs to more recent versions.
 	def content
-		page.revision( @number + 1 ) ? page.revision( @number + 1 ).previous_content : page.content
+		following_revision ? following_revision.previous_content : page.content
 	end
 	
 	# Recreateds the content of the page BEFORE this revision had been made
@@ -21,8 +21,14 @@ class Revision
 		content.split("\n").unpatch!(@changes).join("\n")
 	end
 	
-	# Delegates to the Page object so that can see previous versions
-	def textile( content = self.content ) page.textile( content ) end
+	def previous_revision
+		return nil if number == 0
+		page.revision( number - 1 )
+	end
+	
+	def following_revision
+		page.revision( number + 1 )
+	end
 			
 	def method_missing( symbol, *args )
 		raise(ArgumentError, "Revision does not respond to #{symbol}", caller) unless @page && @page.respond_to?( symbol )
@@ -41,10 +47,9 @@ class Page
 	
 	# Returns an empty version of itself.
   	def self.empty( name )
-	    empty = self.new( name )
-		empty.revise( $MESSAGES[:Type_what_you_want_here_and_click_save], "NoOne" )
+	   empty = self.new( name )
+	   empty.revise( $MESSAGES[:Type_what_you_want_here_and_click_save], "NoOne" )
 	    class << empty
-	      def textile; "[[#{$MESSAGES[:Create]} #{name} => /edit/#{name} ]]" end
 			def empty?; true; end
 	    end
 	    empty
@@ -60,15 +65,9 @@ class Page
   	# Revises the content of this page, creating a new revision class that stores the changes
 	def revise( new_content, author )
 		return nil if new_content == @content
-		#I've abandoned this, because it tends to confuse users.
-		#if the_same_author_recently_revised_this_page( author )
-		#	changes = changes_between(  previous_content, new_content )
-		#	@revisions[-1] = Revision.new( self,  @revisions.length - 1, changes , author )
-		#else
-			changes = changes_between( @content, new_content )
-			return nil if changes.empty?
-			@revisions << Revision.new( self,  @revisions.length, changes , author ) 
-		#end
+		changes = new_content.changes_from @content
+		return nil if changes.empty?
+		@revisions << Revision.new( self,  @revisions.length, changes , author )
 		@content = new_content
 		@revisions.last
 	end
@@ -76,13 +75,13 @@ class Page
 	# Returns the content of this page to that of a previous version
 	def rollback( number, author )
 		revise( ( number < 0 ) ? $MESSAGES[:page_deleted] : @revisions[ number ].content, author )
-	end	
+	end
 	
 	def revision( number ) @revisions[ number ] end
 
 	def deleted?
 		( content =~ /^#{$MESSAGES[:page_deleted]}/i ) || 
-		( content =~ /^#{$MESSAGES[:content_moved_to]} /i )
+		( content =~ /^#{$MESSAGES[:content_moved_to]} /i ) ? true : false
 	end
 	
 	def empty?; @revisions.empty? end
@@ -96,10 +95,10 @@ class Page
 	def is_inserted_into( page )
 		@links_lock.synchronize { @inserted_into << page unless @inserted_into.include? page }
 	end
-	
-	def textile( content = @content ) content end
 		
 	def name_for_index; name.downcase end
+	
+	# Refactored changes_between into the String class in soks-utils
 		
 	# Any unhandled calls are passed onto the latest revision (e.g. author, creation time etc)
 	def method_missing( symbol, *args )
@@ -109,20 +108,10 @@ class Page
 			raise ArgumentError,"Page does not respond to #{symbol}", caller
 		end
 	end
-	
-	private
-	
-	def changes_between( old_content, new_content )
-		old_content.split("\n").diff( new_content.split("\n") ).map { |changeset| changeset.map { |change| change.to_a } }
-	end
-	
-	# This is no longer used, because I've found it confuses people.
-	def the_same_author_recently_revised_this_page( author )
-		return false if empty? 
-		return false unless author == self.author
-		((Time.now - self.revised_on) < (60*5) ) # 5 Minutes
-	end
-	
+end
+
+class EmptyPage < Page
+	def empty?; true; end
 end
 
 #Serves as a marker, so ImagePage and AttachmentPage can re-use the same view templates
@@ -130,43 +119,50 @@ class UploadPage < Page
 end
 
 class ImagePage < UploadPage
-  def textile( content = @content )	
-  	deleted? ? content : "!#{$SETTINGS[:url]}#{content.strip}!:#{$SETTINGS[:url]}/view/#{@name.url_encode}" 	
-  end
-  
   def name_for_index; 	@name[10..-1].strip.downcase	end
 end
 
 class AttachmentPage < UploadPage 
-  def textile( content = @content )
-  	deleted? ? content :  %Q{[[ #{name} => #{$SETTINGS[:url]}#{content} ]]\n} 	
-  end
   def name_for_index; 	@name[ 9..-1].strip.downcase end
 end
 
 # This class has turned into a behmoth, need to refactor.
 class Wiki
 	include WikiFlatFileStore
+	include WikiCacheStore
 	include Enumerable
 	include Notify # Will notify any watchers if underlying files change
+	
+	attr_accessor :check_files_every
 	 
 	PAGE_CLASSES = [ 
 	      [ /^picture of/i, ImagePage ],
 	      [ /^attached/i, AttachmentPage ],
 	      [ /.*/, Page ]
 	    ]
+	    
+	CACHE_NAME = 'pages'
 
-	def initialize( folder )
-		@folder = folder
-		@pages = {}
+	def initialize( content_folder, cache_folder = nil )
+		@cache_folder = cache_folder
+		@folder = content_folder
+		@pages = load_cache(CACHE_NAME) || {}
 		@shutting_down = false
+		@check_files_every = nil
+		watch_for(:start) { start }
+	end
+	
+	def start
 		load_all_pages
 		start_watching_files
+		setup_periodic_notifications
 	end
 	
 	def shutdown
+		notify :shutdown
 		sleep(1) until event_queue.empty?
 		@shutting_down = true # Stop further modifications
+		save_cache(CACHE_NAME, @pages)
 	end
 	
 	def page( name )
@@ -178,7 +174,7 @@ class Wiki
 	end
 	
 	def exists?( name )
-	    @pages.include?( name.downcase ) && !page( name.downcase ).deleted?
+	    @pages.include?( name.downcase ) && !page_named( name ).deleted?
 	end
   
 	def revise( pagename, content, author )
@@ -187,22 +183,43 @@ class Wiki
 		mutate( pagename ) { |page| page.revise( content, author ) }
 	end
 	
+	def move( old_pagename, new_pagename, author )
+		old_content = page(old_pagename).content
+		revise( old_pagename, "#{$MESSAGES[:content_moved_to]} [[#{new_pagename}]]", author )
+		revise( new_pagename, "#{$MESSAGES[:content_moved_from]} [[#{old_pagename}]]", author )
+		revise( new_pagename, old_content, author )
+	end
+	
 	def rollback( pagename, number, author )
 		raise "Sorry! Shutting down..." if @shutting_down
 		check_disk_for_updated_page pagename
 		mutate( pagename ) { |page| page.rollback( number, author ) }
 	end
 	
+	def delete( pagename, author )
+		revise( pagename, $MESSAGES[:page_deleted], author )
+	end
+	
+	def wipe_from_disk( pagename )
+		page = page_named( pagename )
+		raise "Page not deleted!" unless page.deleted?
+		page.content_lock.synchronize do
+			delete_files_for_page( pagename.downcase )
+			@pages.delete( pagename.downcase )
+		end
+	end
+	
 	private 
 	
+	def setup_periodic_notifications
+		PeriodicNotification.new( :year, :month, :day, :hour, :min ) do |period|
+			notify period unless @shutting_down
+		end	
+	end
+	
 	def start_watching_files
-		return unless $SETTINGS[:check_files_every]
-		Thread.new do
-			loop do 
-				sleep $SETTINGS[:check_files_every]
-				load_all_pages
-			end
-		end.priority = -5
+		return unless check_files_every
+		watch_for(check_files_every) { load_all_pages }
 	end
 
 	def new_page( name, initializer = :new )
@@ -216,8 +233,19 @@ class Wiki
 		page = page_named( pagename ) || new_page( pagename )
 		revision = nil
 		page.content_lock.synchronize do
+			# Check if the capitalisation of the page has changed
+			unless page.name == pagename
+				move_files_for_page( page.name, pagename )
+				page.name = pagename
+				notify :page_title_recapitalized, page
+			end
+			# Yield to the mutator block
 			revision, dont_save = yield page
-			save page if revision && dont_save != :dont_save
+			# Save page if required
+			if revision && dont_save != :dont_save
+				save page 
+				add_page_to_index( page )
+			end 
 		end
 		if revision
 			notify :page_revised, page, revision