gf-Soks 1.0.4

data/lib/helpers/mail2wiki-helper.rb

@@ -0,0 +1,105 @@
+require 'net/imap'
+
+# From Dave Burt on comp.lang.ruby
+class String
+ def from_quoted_printable
+   self.gsub(/\r\n/, "\n").gsub(/=(?![\dA-F]{2})/,'=3D').unpack("M").first
+ end
+end
+
+class Message
+	
+	attr_reader :message_id, :subject, :sender_name, :sender_email, :date, :text
+
+	def initialize( imap, message_id )
+		@imap, @message_id = imap, message_id
+		envelope = @imap.fetch( @message_id, 'ENVELOPE' ).first.attr['ENVELOPE']
+		@subject = envelope['subject'].gsub(/^(Fw|Re):?/i,'').strip
+		@sender_name = envelope['from'].first['name']
+		@date = envelope['date']
+		@sender_email = envelope['from'].first['mailbox'] + ' at ' + envelope['from'].first['host']
+		@sender_name = @sender_email unless @sender_name && @sender_name.size > 1
+		@sender_name.gsub!(/@/,' at ')
+		@text = plain_text_content_from_message( message_id )
+	end
+	
+	def plain_text_content_from_message( id )
+		@imap.fetch( id, 'BODY[1]' ).first.attr['BODY[1]'].from_quoted_printable
+	end
+
+end
+
+class Mail2WikiHelper
+
+	DEFAULT_SETTINGS = {
+		:server => 'imap.hermes.cam.ac.uk',
+		:username => 'tamc2',
+		:password => 'missing_a_password',
+		:mailbox => 'test',
+		:check_event => :hour,
+		:subject_regexp => /.*/,
+		:keyword => 'PutInWiki'
+	}
+	
+	def initialize( wiki, settings = {} )
+		@settings = DEFAULT_SETTINGS.merge( settings )
+		@wiki = wiki
+		check_mailbox
+		@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
+		end
+		logout
+	end
+	
+	def add_message_to_wiki( message )
+		current_page = @wiki.page( message.subject )
+		if current_page.empty?
+			text = "h1. #{message.subject}"
+		else
+			text = current_page.textile
+		end
+		text << "\n\n"
+		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
+	
+	def login
+		@imap = Net::IMAP.new(@settings[:server])
+		@imap.login( @settings[:username], @settings[:password] )
+	end
+	
+	def logout
+		@imap.logout
+		@imap.disconnect
+	end
+	
+	def select_mailbox
+		@imap.select @settings[:mailbox]
+	end
+	
+	def new_messages_for_wiki 
+		@imap.search("UNKEYWORD #{@settings[:keyword]}").each { |id| yield id } 		
+	end
+	
+	def mark_as_added( id )
+		@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, minimum_revisions = 20 ) 
+		@wiki = wiki
+		@age_to_wipe_at = age_to_wipe_at
+		@maximum_revisions = minimum_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

@@ -0,0 +1,47 @@
+require 'rss/1.0'
+require 'rss/2.0'
+require 'open-uri'
+
+class RSS2WikiHelper
+
+	DEFAULT_SETTINGS = {
+		:url => 'http://localhost:8000/rss/recent%20changes%20to%20this%20site',
+		:pagename => nil, # If nil, uses channel title,
+		:update_on_event => :hour,
+		:author => 'AutomaticRSS2Wiki',
+	}
+	
+	def initialize( wiki, settings = {} )
+		@settings = DEFAULT_SETTINGS.merge( settings )
+		@wiki = wiki
+		update_rss
+		update_wiki
+		@wiki.watch_for(@settings[:update_on_event]) do 
+			update_rss
+			update_wiki
+		end
+	end
+	
+	def update_wiki
+		@wiki.revise( @settings[:pagename] || @rss.channel.title, render, @rss.items.first.respond_to?('author') ? @rss.items.first.author : "AutomaticRSS" )
+	end
+
+	def render
+		content = "h1. #{@rss.channel.title}\n\n"
+		@rss.items.each do |item| 
+			content << "# [[ #{escape(item.title)} => #{item.link} ]]\n"
+		end
+		content
+	end
+
+	def update_rss
+		$LOG.info "Updating feed"
+		open(@settings[:url]) do |http| 
+			@rss = RSS::Parser.parse( http.read , false) 
+		end
+	end
+	
+	def escape( string )
+		string.tr('[]=>','')
+	end
+end

data/lib/helpers/wiki2html.rb

@@ -0,0 +1,60 @@
+class Wiki2Html
+	
+	DEFAULT_SETTINGS = {
+		:views_to_copy => ['view','meta','rss'],
+		:extension => '.html',
+		:destination_dir => '/Users/tamc2/Sites',
+		:destination_url => 'http://localhost/~tamc2'
+	}
+	
+	def initialize( wiki, view, settings = {} )
+		@settings = DEFAULT_SETTINGS.merge( settings )
+		@wiki, @view = wiki, view
+		@wiki.watch_for( :page_created, :page_deleted ) { |event, page| new_page( page ) }
+		@wiki.watch_for( :page_revised ) { |event, page| page_revised( page ) }
+		update_all_pages
+	end
+
+	def new_page( page )
+		copy_all_views( page.name )
+		titleregex = Regexp.new( page.name, Regexp::IGNORECASE )
+		@wiki.each { |name, linkedpage | 
+			page_revised( linkedpage ) if linkedpage.textile =~ titleregex
+		}
+	end
+	
+	def page_revised( page )
+		copy_all_views( page.name )
+		page.inserted_into.each { |including_page| copy_all_views( including_page.name ) }
+	end
+	
+	def update_all_pages
+		@wiki.each { |pagename, page| copy_all_views( pagename) }
+	end
+	
+	def copy_all_views( pagename )
+		@settings[:views_to_copy].each { |view| copy_view( pagename, view ) }
+	end
+	
+	def copy_view( pagename, view )
+		$stderr.puts "Copying #{pagename} #{view}"
+		html =  @view.view( pagename, view )
+		update_links html
+		destination = "#{@settings[:destination_dir]}/#{view}/#{pagename}#{@settings[:extension]}".downcase
+		File.mkpath(File.dirname(destination)) unless File.exists?(File.dirname(destination))
+		File.open( destination,'w') {|file| file.puts html}
+	end
+	
+	def update_links( html )
+		old_link = /['"]#{$SETTINGS[:url]}\/(.*?)\/(.*?)(\.\w*)?['"]/
+		html.gsub!(old_link) do |match|
+			if ($1.downcase == 'attachment' || @settings[:views_to_copy].include?( $1.downcase ))
+				"'#{@settings[:destination_url]}\/#{$1.downcase}\/#{$2.downcase}#{$3 || @settings[:extension]}'"
+			else
+				match
+			end
+		end
+		html
+	end	
+	
+end

data/lib/soks-model.rb

@@ -0,0 +1,271 @@
+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 
+	alias :revised_on :created_on
+	
+	def initialize( page, number, changes, author, created_on = Time.now )
+		@page, @number, @changes, @author, @created_on = page, number, changes, author, created_on
+	end
+	
+	# Recreates the content of the page AFTER this revision had been made.
+	# Done by recursively applying diffs to more recent versions.
+	def content
+		following_revision ? following_revision.previous_content : page.content
+	end
+	
+	# Recreateds the content of the page BEFORE this revision had been made
+	def previous_content
+		content.split("\n").unpatch!(@changes).join("\n")
+	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 )
+		@page.send symbol, *args
+	end
+	
+	# To allow the contents to be dumped in a class independent way.
+	# Must match the order of the variables used in initialize
+	def to_a() [@number, @changes, @author, @created_on] end	
+end
+
+class Page
+	attr_accessor :content_lock, :name, :content, :revisions
+	attr_accessor :links_lock, :links_from, :links_to, :inserted_into
+	alias :to_s	:name
+	
+	# 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" )
+	    class << empty
+			def empty?; true; end
+	    end
+	    empty
+    end
+
+	def initialize( name )
+		@content_lock, @links_lock = Mutex.new, Mutex.new
+		@name, @content, @revisions = name, "", []
+		@links_from, @links_to = [], [] 
+		@inserted_into = []
+	end
+  	
+  	# 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
+		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
+
+	# 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
+	
+	def revision( number ) @revisions[ number ] end
+
+	def deleted?
+		( content =~ /^#{$MESSAGES[:page_deleted]}/i ) || 
+		( content =~ /^#{$MESSAGES[:content_moved_to]} /i ) ? true : false
+	end
+	
+	def empty?; @revisions.empty? end
+
+	def <=>( otherpage ) self.score <=> otherpage.score end
+
+	def score; @links_from.size + @links_to.size end
+		
+	def created_on; @revisions.first.created_on end
+	
+	def is_inserted_into( page )
+		@links_lock.synchronize { @inserted_into << page unless @inserted_into.include? page }
+	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 )
+		if @revisions.last && @revisions.last.respond_to?(symbol)
+			@revisions.last.send symbol, *args
+		else
+			raise ArgumentError,"Page does not respond to #{symbol}", caller
+		end
+	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
+class UploadPage < Page
+end
+
+class ImagePage < UploadPage
+  def name_for_index; 	@name[10..-1].strip.downcase	end
+end
+
+class AttachmentPage < UploadPage 
+  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( 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 )
+	 	page_named( name )|| new_page( name, :empty )
+	end
+	
+	def each( exclude_deleted = true )
+		@pages.each { |name, page| yield [name, page] unless exclude_deleted && page.deleted? }
+	end
+	
+	def exists?( name )
+	    @pages.include?( name.downcase ) && !page_named( name ).deleted?
+	end
+  
+	def revise( pagename, content, author )
+		raise "Sorry! Shutting down..." if @shutting_down
+		check_disk_for_updated_page pagename
+		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 check_files_every
+		watch_for(check_files_every) { load_all_pages }
+	end
+
+	def new_page( name, initializer = :new )
+		PAGE_CLASSES.each do |regex,klass|
+			return klass.send( initializer, name) if name =~ regex
+		end
+	end
+		
+	def mutate( pagename )
+		didexist = exists? pagename
+		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 required
+			if revision && dont_save != :dont_save
+				save page 
+				add_page_to_index( page )
+			end 
+		end
+		if revision
+			notify :page_revised, page, revision
+			if page.deleted?
+				notify :page_deleted, page, revision
+			elsif !didexist
+				notify :page_created, page, revision
+			end
+		end
+	end
+	
+	def add_page_to_index( page )
+		@pages[ page.name.downcase ] = page
+		page
+	end
+	
+	def page_named( pagename )
+		@pages[ pagename.downcase ]
+	end
+
+end
+
+