Soks 0.0.7 → 1.0.0

data/lib/soks-servlet.rb

@@ -2,158 +2,176 @@
 require 'authenticators'
 require 'yaml'
 
-# Default settings moved to soks.rb
+class ServletSettings
+	
+	attr_accessor :view_controller, :wiki
+	attr_accessor :home_page
+	attr_accessor :default_view
+	attr_accessor :upload_directory
+	attr_accessor :authenticators
+	attr_accessor :static_file_directories 
+	attr_accessor :force_no_cache
+	attr_accessor :content_types
+	attr_accessor :wiki_directory
+	
+	def initialize( wiki, view_controller )
+		@wiki, @view_controller = wiki, view_controller
+		@home_page = 'Home Page'
+		@default_view = 'view'
+		@authenticators = []
+		@static_file_directories = {}
+		@content_types = {}
+		@force_no_cache = false
+	end
+	
+	def url
+		@view_controller.root_url
+	end
+	
+	def page_name_for_url_name( url_name )
+		@view_controller.page_name_for_url_name( url_name )
+	end
+	
+	def url_name_for_page_name( page_name )
+		@view_controller.url_name_for_page_name( page_name )
+	end
+end
 
 class WikiServlet < WEBrick::HTTPServlet::AbstractServlet
-
-	def initialize( server, view, settings )
-		@server, @view, @wikiurl, @authenticators = server, view, settings[:url] , settings[:authenticators]
+	
+	attr_accessor :server, :settings
+	
+	def initialize( server, servlet_settings )
+		@server, @settings = server, servlet_settings
 	end
 		
 	def service( request, response )
-		case request.path
-		when '/robots.txt', '/favicon.ico' # Catch some requests to static files
-			doAttachment( request, response, request.path[1..-1] )
-		when /\/(\w+?)\/(.+)/ # If request of the form /verb/pagename then doVerb on this class
-			verb, pagename = $1, make_pagename_valid( $2 )
-			authenticate request, response
-			make_username_valid( request )	
-			if self.respond_to?( "do#{verb.capitalize}" )
-				self.send( "do#{verb.capitalize}", request, response, pagename, request.user )
-			else
-				unknownView( request, response, pagename, verb, request.user )
-			end
-		when /\/(.+)/	; redirect( response, $1, 'view' )	 # No verb given
-		when "/"			; redirect( response, $SETTINGS[:home_page], 'view' ) # No page or verb given
-		end
+		case request.path_info
+		
+		# Pass some requests directly to static files
+		when '/robots.txt', '/favicon.ico'; serveStaticFile( request, response, request.path[1..-1], 'Attachment' )
 		
-		if $SETTINGS[:force_no_cache]		
-			response['Cache-control'] ||= 'no-cache'
-			response['Pragma'] ||= 'no-cache'
+		# If request of the form /verb/pagename then do it
+		when /\/(\w+?)\/(.+)/; wiki_service( request, response, $1.capitalize, $2 )
+	 	
+	 	# If request of the form /pagename then redirect to /view/pagename
+		when /\/(.+)/	; redirect( response, $1, settings.default_view )
+		
+		# If request of the form / then redirect to /view/home%20page
+		when "/"		; redirect( response, settings.home_page, settings.default_view )
+
 		end
-	end 
+	end
+	
+	def wiki_service( request, response, verb, url_name )
+		authenticate request, response
+		make_username_valid( request )
+		if settings.static_file_directories.include? verb
+			serveStaticFile( request, response, url_name, verb )	
+		elsif self.respond_to?( "do#{verb}" )
+			self.send( "do#{verb}", request, response,settings.page_name_for_url_name(url_name), request.user )
+			set_cache_settings(response)
+		else
+			renderView( request, response, settings.page_name_for_url_name(url_name), verb, request.user )
+			set_cache_settings(response)
+		end
+	end
 	
 	def authenticate( request, response )
-		@authenticators.each do |path_regex,authenticator|
-			if request.path.downcase =~ path_regex
+		settings.authenticators.each do |path_regex,authenticator|
+			if request.path_info.downcase =~ path_regex
 				authenticator.authenticate( request, response )
 				break
 			end
 		end
 	end
 	
-	def redirect( response, pagename, verb = 'view' )
-		pagename = pagename.url_encode # Reformat into url encoding
-		response.set_redirect(WEBrick::HTTPStatus::Found, verb ? "#{@wikiurl}/#{verb}/#{pagename}" : "#{@wikiurl}/#{pagename}")
-	end
-	
-	# These methods deal with the various views
-		
-	def doAttachment( request, response, pagename, person = nil )
-		request.script_name = 'attachment'
-	  	request.path_info = "/#{pagename}"
-		WEBrick::HTTPServlet::FileHandler.get_instance(@server, "#{$SETTINGS[:root_directory] }/attachment",true).service(request, response)
-	end
-
-	def doFind( request, response, pagename, person ) 
-		response.body = @view.find( request.query['regex'].strip )
-		response['Content-Type'] ||= "text/html"
+	# A special redirect to allow WikiLink style urls
+	# Not sure if used by anyone, so may delete
+	def doWiki( request, response, pagename, person )
+		redirect( response, pagename.gsub(/([a-z])([A-Z])/,'\1 \2') )
 	end
 	
-	def doRss( request, response, pagename, person )
-		response.body = @view.view( pagename, 'rss', person )
-		response["Content-Type"] = "application/xml"
+	# This passes any requests for static files onto a FileHandler
+	def serveStaticFile( request, response, url_name, view )
+		request.script_name = view
+	  	request.path_info = "/#{url_name}"
+		WEBrick::HTTPServlet::FileHandler.get_instance(@server, settings.static_file_directories[view], true).service(request, response)
 	end
 	
-	# This captures all unkown view types
-	def unknownView( request, response, pagename, view, person )
-		response.body = @view.view( pagename, view, person )
-		response['Content-Type'] ||= "text/html"
+	# This passes any rendering of the page onto the view class
+	def renderView( request, response, pagename, view, person )
+		response.body = view_controller.render( pagename, view, person, request.query )
+		response['Content-Type'] = settings.content_types[view] || 'text/html'
 	end
 
 	# All the following methods change the wiki, then redirect
-
-	def doWiki( request, response, pagename, person )
-		redirect( response, pagename.gsub(/([a-z])([A-Z])/,'\1 \2') )
-	end
 	
 	def doSave( request, response, pagename, person )
-		content = request.query["content"].to_s
-		newpagename = make_pagename_valid( request.query["titleprefix"].to_s + request.query["newtitle"].to_s)
-		@view.revise( pagename, content.gsub(/\r\n/,"\n"), person, newpagename) if content
-		redirect( response, newpagename )
+		pagename = move_page_as_required( request, response, pagename, person )
+		content = request.query["content"].to_s.gsub(/\r\n/,"\n")
+		wiki.revise( pagename, content, person ) if content
+		redirect( response, pagename )
 	end
 	
 	def doRollback( request, response, pagename, person )
-		revision = request.query['revision'] ? request.query['revision'].to_i : nil
-		@view.rollback( pagename, revision, person ) if revision
+		if request.query['revision']
+			wiki.rollback( pagename, request.query['revision'].to_i, person )
+		end
 		redirect( response, pagename )
 	end
 	
 	def doDelete( request, response, pagename, person )
-		@view.delete( pagename, person )
+		wiki.delete( pagename, person )
 		redirect( response, pagename )
 	end
 	
 	def doUpload( request, response, pagename, person )
-		newpagename = make_pagename_valid( request.query["titleprefix"].to_s + request.query["newtitle"].to_s)
+		pagename = move_page_as_required( request, response, pagename, person )
 		unless request.query['file'] == ""
-			@view.revise( pagename, upload_file_data( request.query['file'] ), person, newpagename )
-		else
-			@view.move( pagename, person, newpagename )
-		end
-		redirect( response, newpagename )
+			filename = upload_file_data( request.query['file'] )	
+			wiki.revise( pagename, filename, person )
+		end 
+		redirect( response, pagename )
 	end
 
 	private
+	
+	def redirect( response, pagename, verb = settings.default_view )
+		response.set_redirect( WEBrick::HTTPStatus::Found, "#{settings.url}/#{verb}/#{settings.url_name_for_page_name(pagename)}" )
+	end
+	
+	# Moves a page if there is a newtitle in the query
+	# If the original page had 'type a title' in its tile, then it is assumed to be a template
+	# and therefore is not moved.
+	def move_page_as_required( request, response, pagename, person )
+		new_pagename = "#{request.query["titleprefix"]}#{request.query["newtitle"]}"
+		return new_pagename if pagename =~ /#{$MESSAGES[:Type_a_title_here]}/io 
+		return pagename if new_pagename == pagename
+		wiki.move( pagename, new_pagename, person )
+		new_pagename
+	end
 		
-	def upload_file_data( upload_data  )
-		path = "#{$SETTINGS[:root_directory]}/attachment/"
+	def upload_file_data( upload_data, destination = settings.upload_directory  )
+		return "Uploads prohibited" unless destination
+		path = settings.static_file_directories[ destination ]
 		filename = File.unique_filename( path , upload_data.filename )
 		File.open( File.join( path, filename ), 'wb' ) { |file| upload_data.list.each { |data| file << data } }
-		"/attachment/#{filename}"
+		"/#{destination}/#{filename}"
 	end
 	
-	# Certain characters cause problems in titles, so delete
-	def make_pagename_valid( pagename )
-		pagename.to_valid_pagename
+	# Make sure the username doesn't start with Automatic
+	def make_username_valid( request )
+		request.user = "User: #{request.user}" if request.user =~ /^Automatic/i
 	end
 	
-	# Because the username is also used as a page title, also delete troublesome characters from them
-	# and make sure the name doesn't start with Automatic
-	def make_username_valid( request )
-		request.user = request.user.to_valid_pagename
-		request.user = "External #{request.user}" if request.user =~ /^Automatic/i
+	def set_cache_settings(response)
+		return unless @settings.force_no_cache		
+		response['Cache-control'] ||= 'no-cache'
+		response['Pragma'] ||= 'no-cache'
 	end
-end
-
-def start_wiki( settings = {}, &automatic_agents )
-
-	$SETTINGS.merge! settings	
-	$MESSAGES = YAML.load( IO.readlines("#{$SETTINGS[:root_directory]}/views/messages.yaml").join )
-	
-	wiki = Wiki.new( "#{$SETTINGS[:root_directory]}/content" )
-	view = View.new( wiki, $SETTINGS[:name] )
-	
-	Thread.new( automatic_agents, wiki, view ) do |block, wiki, view|
-		$LOG.info "Starting helper classes"
-		block.call( wiki, view )
-		$LOG.info "Finished starting helper classes"
-	end.priority = -2
-	
-	server = WEBrick::HTTPServer.new( { :Port => $SETTINGS[:port], 
-										:ServerType=> $SETTINGS[:server_type] 
-										} )
-												
-	server.mount("/", WikiServlet, view, $SETTINGS  )
-
-	trap("INT") { 
-		$LOG.warn "Trying to shutdown gracefully"
-		server.shutdown 
-		wiki.shutdown
-		$LOG.info "Shutdown."
-	}
-
-	$LOG.warn "Starting server"
-	server.start
-end
+	
+	def wiki; @settings.wiki end
+	def view_controller; @settings.view_controller end
+	
+end

data/lib/soks-storage.rb

@@ -1,3 +1,48 @@
+module WikiCacheStore
+	
+	CACHE_EXTENSION = ".marshal"
+	
+	def load_cache( cache_name )
+		return nil unless @cache_folder
+		
+		cache = nil
+		
+		File.open( cache_filename_for( cache_name ) ) do |f|
+			cache = Marshal.load(f)
+		end
+		
+		File.delete( cache_filename_for( cache_name ) )
+		
+		$LOG.info "Loaded #{cache_name} cache"
+		
+		return cache
+		
+		rescue ArgumentError
+			$LOG.warn "#{cache_name} cache corrupt (bad characters in file)"
+			return nil 
+		
+		rescue EOFError
+			$LOG.warn "#{cache_name} cache corrupt (unexpected end of file)"
+			return nil 
+			
+		rescue Errno::ENOENT
+			$LOG.warn "#{cache_name} cache not found"
+			return nil
+	end
+	
+	def save_cache( cache_name, cache_object )
+		return nil unless @cache_folder
+		File.open( cache_filename_for( cache_name ), 'w' ) do |f|
+			f.puts Marshal.dump(cache_object)
+		end
+	end
+	
+	def cache_filename_for( name )
+		File.join( @cache_folder, "#{name}#{CACHE_EXTENSION}")
+	end
+
+end
+
 module WikiFlatFileStore
 
 	CONTENT_EXTENSION = '.textile'
@@ -15,8 +60,22 @@ module WikiFlatFileStore
 		 end
 	end
 	
+	def save( page )
+		save_content( page )
+		save_last_revision( page )
+	end
+	
+	def delete_files_for_page( page_name )
+		File.delete( filename_for_content( page_name ), filename_for_revisions( page_name ) )
+	end
+	
+	def move_files_for_page( old_page_name, new_page_name )
+		File.rename( filename_for_content( old_page_name ), filename_for_content( new_page_name ) )
+		File.rename( filename_for_revisions( old_page_name ), filename_for_revisions( new_page_name ) )
+	end
+
 	def check_disk_for_updated_page( pagename, force = false )
-		return unless force || $SETTINGS[:check_files_every] # We don't care about file changes 
+		return unless force || self.check_files_every # We don't care about file changes 
 		filename = filename_for_content( pagename )
 		return :file_does_not_exist unless File.exists?( filename ) # File doesn't exist on disk
 		return load_page( filename ) unless page_named( pagename )# File is new on the disk, but not yet in memory 
@@ -38,7 +97,7 @@ module WikiFlatFileStore
 			if content_newer_than_revisions?( page ) # The textile file has been modified, but the array file has not been updated to match
 				page.content = reconstruct_content_from_revisions( page.revisions )
 				page.revise( disk_content, DEFAULT_AUTHOR )
-				save_revisions( page )
+				save_last_revision( page )
 			else # The textile file and the array file are in sync.
 				page.content = disk_content
 			end
@@ -84,24 +143,18 @@ module WikiFlatFileStore
 	def move_files_if_names_are_not_url_encoded
 		Dir[ File.join( @folder, "*#{CONTENT_EXTENSION}" ) ].each do |filename|
 			basename = File.basename( filename, '.*')
-			next if basename.url_decode.to_valid_pagename.url_encode == basename # All ok, so no worry
-			new_name = File.join( File.dirname(filename), File.unique_filename( File.dirname(filename), basename.url_decode.to_valid_pagename.url_encode +  File.extname( filename) ) )
+			next if basename.url_decode.url_encode == basename # All ok, so no worry
+			new_name = File.join( File.dirname(filename), File.unique_filename( File.dirname(filename), basename.url_decode.url_encode +  File.extname( filename) ) )
 			File.rename(filename, new_name )
 		end
 	end
-
-	def save( page )
-		add_page_to_index( page )
-		save_content( page )
-		save_revisions( page )
-	end
 	
 	def save_content( page )
 		File.open(filename_for_content( page.name ), 'w' ) { |file| file.puts page.content }
 	end
 	
 	# Appends the last revision onto the yaml file	
-	def save_revisions( page )
+	def save_last_revision( page )
 		$LOG.info "Saving revisions for #{page.name}"
 		File.open(filename_for_revisions( page.name ), 'a' ) do |file| 
 			YAML.dump( page.revisions.last.to_a, file )
@@ -109,6 +162,16 @@ module WikiFlatFileStore
 		end
 	end
 	
+	def save_all_revisions( page )
+		$LOG.warn "Saving all revisions for #{page.name}"
+		File.open(filename_for_revisions( page.name ), 'w' ) do |file|
+			page.revisions.each do |revision| 
+				YAML.dump( revision.to_a, file )
+				file.puts # Needed to ensure that documents are separated
+			end
+		end
+	end
+	
 	def page_name_for( filename )
 		File.basename( filename, '.*').url_decode	
 	end

data/lib/soks-utils.rb

@@ -30,8 +30,10 @@ class EventQueue
 	end
 	
 	def event( event, messages )
+		# $LOG.warn "#{event}, #{messages}"
 		check_thread_ok
 		@queue.enq [ event, messages ]
+		$LOG.warn "Notification queue backlog of #{@queue.size}" if @queue.size > 100
 		notify_attentive_watchers( event, *messages )
 	end
 	
@@ -74,7 +76,7 @@ class EventQueue
 			begin 
 				action_block.call(event, *messages)
 			rescue StandardError => err
-				$stderr.puts "ERROR #{err}: #{event} - #{messages.join(' ')}"
+				$LOG.warn "ERROR #{err}: #{event} - #{messages.join(' ')}"
 				err.backtrace.each { |s| $stderr.puts s }
 			end 
 		}
@@ -106,7 +108,31 @@ class EventQueue
 	def attentive_watchers
 		@attentive_watchers ||= {}
 	end
+end
+
+class PeriodicNotification
+	
+	def initialize( *notify_about, &block)
+		@block = block
+		notify_about.each do |period|
+			start_thread( period )
+		end			
+	end
+	
+	private
+	
+	def start_thread( period )
+		Thread.new( period ) do |period|
+			while true
+				sleep seconds_to_next_period( period )
+				@block.call( period )
+			end
+		end
+	end
 	
+	def seconds_to_next_period( period )
+		Time.now.next( period ) - Time.now
+	end
 end
 
 class String
@@ -145,9 +171,15 @@ class String
 	end
 	
 	# Removes punctuation and spaces that can cause problems with page names
-	def to_valid_pagename
-		self.tr('\\\[]?{}&^`<>/','').strip
+	#def to_valid_pagename
+	#	self.tr('\\\[]?{}#&^`<>/','').strip
+	#end
+	
+	#Returns the changes between the lines of this string and another
+	def changes_from( other_string )
+		other_string.split("\n").diff( self.split("\n") ).map { |changeset| changeset.map { |change| change.to_a } }
 	end
+	
 end
 
 class FiniteUniqueList
@@ -223,13 +255,55 @@ class Numeric
 end
 
 class Time
+	
+	# Returns 'yesterday', 'tomorrow' for date relative to now
+	def relative_day
+		# Days difference
+		case self.days_from( Time.now ) 			
+		when -7..-2	; 	strftime('Last %A')
+		when -1 	; 	"Yesterday"
+		when 0 		; 	"Today"
+		when 1 		; 	"Tomorrow"
+		when 2..7	;	strftime('%A')
+		else		; 	strftime( (Time.now.year == self.year) ? '%d %b' :'%d %b %Y')
+		end
+	end
 
+	def days_from( other_time )
+		((Time.local(self.year, self.month, self.day)-Time.local(other_time.year, other_time.month, other_time.day))/(24*60*60)).round
+	end
+	
 	# Checks whether two times are on the same day
 	def same_day?( other_time )
 		return false unless other_time.year == self.year
 		return false unless other_time.yday == self.yday
 		return true
 	end
+	
+	# Returns the Time at the next occurance of the period
+	def next( period )
+		case period
+		when :sec, :second
+			next_time = self + 1
+			Time.local( next_time.year, next_time.month, next_time.day, next_time.hour, next_time.min, next_time.sec )
+		when :min, :minute
+			next_time = self + 60
+			Time.local( next_time.year, next_time.month, next_time.day, next_time.hour, next_time.min )
+		when :hour
+			next_time = self + ( 60*60 )
+			Time.local( next_time.year, next_time.month, next_time.day, next_time.hour)
+		when :day
+			next_time = self + ( 60*60*24 )
+			Time.local( next_time.year, next_time.month, next_time.day)
+		when :mon, :month
+			next_time = self + ( 60*60*24*(32-self.day) )
+			Time.local( next_time.year, next_time.month)
+		when :year
+			next_time = self + ( 60*60*24*(367-self.yday) )
+			Time.local( next_time.year )
+		end
+	end
+	
 end
 
 class File