gf-Soks 1.0.4

data/lib/soks-servlet.rb

@@ -0,0 +1,177 @@
+#!/usr/local/bin/ruby
+require 'authenticators'
+require 'yaml'
+
+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
+	
+	attr_accessor :server, :settings
+	
+	def initialize( server, servlet_settings )
+		@server, @settings = server, servlet_settings
+	end
+		
+	def service( request, response )
+		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 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 /\/(.+)/	; response.set_redirect( WEBrick::HTTPStatus::Found, "#{settings.url}/#{settings.default_view}/#{$1}" )
+		
+		# If request of the form / then redirect to /view/home%20page
+		when "/"		; redirect( response, settings.home_page, settings.default_view )
+
+		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 )
+		settings.authenticators.each do |path_regex,authenticator|
+			if request.path_info.downcase =~ path_regex
+				authenticator.authenticate( request, response )
+				break
+			end
+		end
+	end
+	
+	# 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
+	
+	# 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 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 doSave( request, response, pagename, person )
+		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 )
+		if request.query['revision']
+			wiki.rollback( pagename, request.query['revision'].to_i, person )
+		end
+		redirect( response, pagename )
+	end
+	
+	def doDelete( request, response, pagename, person )
+		wiki.delete( pagename, person )
+		redirect( response, pagename )
+	end
+	
+	def doUpload( request, response, pagename, person )
+		pagename = move_page_as_required( request, response, pagename, person )
+		unless request.query['file'] == ""
+			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, 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 } }
+		"/#{destination}/#{filename}"
+	end
+	
+	# 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
+	
+	def set_cache_settings(response)
+		return unless @settings.force_no_cache		
+		response['Cache-control'] ||= 'no-cache'
+		response['Pragma'] ||= 'no-cache'
+	end
+	
+	def wiki; @settings.wiki end
+	def view_controller; @settings.view_controller end
+	
+end

data/lib/soks-storage.rb

@@ -0,0 +1,187 @@
+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'
+	REVISIONS_EXTENSION = '.yaml'
+	DEFAULT_AUTHOR = 'the import script' 
+
+	def load_all_pages
+		move_files_if_names_are_not_url_encoded
+		pages_on_disk = Dir[ File.join( @folder, "*#{CONTENT_EXTENSION}" ) ].map { |filename| page_name_for( filename )}
+		pages_in_memory = @pages.values.map { |page| page && page.name }
+		( pages_in_memory.compact | pages_on_disk ).each do |pagename| 
+			if check_disk_for_updated_page( pagename, true ) == :file_does_not_exist
+				revise( pagename, $MESSAGES[:page_deleted], DEFAULT_AUTHOR )
+			end
+		 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 || 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 
+		return load_page( filename ) if content_newer_than_revisions?( page_named(pagename) ) # File is newer on disk
+		return nil
+	end
+	
+	def load_page( filename )
+		mutate( page_name_for( filename ) ) do |page|
+			disk_content = load_content( page )
+			return nil if disk_content == page.content # No change, disk is the same as memory
+
+			# We now know that the content on disk is different from that in memory
+			
+			page.revisions = load_revisions( page ) if page.revisions.empty? # Load revisions from disk if none known 
+			# assumes disk revisions are ALWAYS up to date with memory?
+			
+			# We now know what the page content and the page revisions should be. But not if the revisions are up to date	
+			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_last_revision( page )
+			else # The textile file and the array file are in sync.
+				page.content = disk_content
+			end
+		
+			add_page_to_index( page )
+			[ page.revisions.last, :dont_save ]
+		end
+	end
+
+	def load_content( page )
+		IO.readlines( filename_for_content( page.name ) ).join
+	end
+
+	def load_revisions( page )
+		return [] unless File.exists?( filename_for_revisions( page.name ) )
+		revisions = []
+		begin
+			File.open( filename_for_revisions( page.name ) ) { |file| 
+				YAML.each_document( file ) { |array|
+					next unless array.is_a? Array 
+					next unless array.size == 4
+					next unless array[0].is_a? Integer 
+					revisions[ array[0] ] = Revision.new( page, *array ) } 
+			}
+		rescue
+			$LOG.error "Error loading revisions with #{$!.to_s} in file #{page.name}"
+		end
+		revisions.each_with_index { |r,i| $LOG.error "#{page.name} missing revision #{i}" unless r }
+		revisions
+	end
+	
+	def content_newer_than_revisions?( page )
+		return true if page.empty?
+		File.ctime(filename_for_content( page.name )) > File.ctime(filename_for_revisions(page.name))
+	end
+
+	def reconstruct_content_from_revisions( revisions )
+		content = []
+		revisions.each { |revision| content = Diff::LCS.patch( content, revision.changes, :patch ) }
+		content.join("\n")
+	end
+
+	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.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_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_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 )
+			file.puts # Needed to ensure that documents are separated
+		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
+	
+	def filename_for_content( pagename )
+		File.join( @folder, "#{pagename.url_encode}#{CONTENT_EXTENSION}" )
+	end
+
+	def filename_for_revisions( pagename )
+		File.join( @folder, "#{pagename.url_encode}#{REVISIONS_EXTENSION}" )
+	end
+end
+	

data/lib/soks-upgrade-0.0.2.rb

@@ -0,0 +1,70 @@
+require 'soks-utils'
+require 'yaml'
+	
+	# This is the definition of Revision from v-0-0-2.
+	# Much smaller than the current definition. sigh.
+	class Revision
+		attr_reader :number, :changes, :created_at, :author
+
+		def initialize( number, changes, author )
+			@number, @changes, @author = number, changes, author
+			@created_at = Time.now
+		end
+	
+		def content( page )
+			page.revision( @number + 1 ) ? page.revision( @number + 1 ).previous_content( page ) : page.content
+		end
+
+		def previous_content( page )
+			content( page ).split("\n").unpatch!(@changes).join("\n")
+		end
+	end
+
+class SoksUpgrade
+		
+	def load_old_revisions( filename )
+		File.open( filename ) { |file| return Marshal.load( file ) }
+	end
+	
+	def save_new_revisions( old_filename, revisions )
+		File.open(new_filename_for_old( old_filename ), 'w' ) do |file| 
+			revisions.each do |revision|
+				YAML.dump( [revision.number, revision.changes, revision.author, revision.created_at ] , file )
+				file.puts
+			end
+		end
+	end
+	
+	def new_filename_for_old( old_filename )
+		basename = File.basename( old_filename, '.*')
+		new_extension = '.yaml'
+		File.join( File.dirname(old_filename), basename ) + new_extension
+	end
+
+	def upgrade_revisions( directory )
+		search = File.join( directory,'content', "*.marshal" )
+		Dir[ search ].each do |filename|
+			puts "Upgrading #{filename}"
+			save_new_revisions( filename, load_old_revisions( filename ))
+			File.delete filename
+		end
+	end
+	
+	def upgrade_textile( filename )
+		textile = IO.readlines( filename ).join
+		textile.gsub!(/\[\[\s*(.*?)\s*(|:\s*(.*?)\s*)\]\]/) do |m|
+			title, page = $1, $3
+			page ? "[[ #{title} => #{page} ]]" : "[[ #{title} ]]"
+		end
+		File.open( filename, 'w' ) { |f| f.puts textile }	
+	end
+	
+	def upgrade_content( directory )
+		search = File.join( directory,'content', "*.textile" )
+		Dir[ search ].each do |filename|
+			puts "Upgrading #{filename}"
+			upgrade_textile( filename )
+		end
+	end	
+
+end

data/lib/soks-utils.rb

@@ -0,0 +1,327 @@
+# This is a bit like observable, but for events
+module Notify
+	
+	# Will notify in a separate low priority thread
+	def watch_for( *events , &action_block )
+		self.event_queue.watch_for( events, action_block )
+	end
+	
+	# Will notify in the running high priority thread (ie will block response to user)
+	def watch_attentively_for( *events, &action_block )
+		self.event_queue.watch_attentively_for( events, action_block )
+	end
+	
+	def notify( event, *messages)
+		raise "Sorry! Shutting down..." if @shutting_down
+		self.event_queue.event( event, messages )
+	end
+	
+	def event_queue
+		@event_queue ||= EventQueue.new
+	end
+	
+end
+
+class EventQueue
+
+	def initialize
+		@queue = Queue.new
+		start_thread
+	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
+	
+	# Will call the action_block lazily
+	def watch_for( events , action_block )
+		events.each { |event| watchers_for(event) << action_block }
+	end
+	
+	# Will call the action_block imediately
+	def watch_attentively_for( events, action_block )
+		events.each { |event| attentive_watchers_for(event) << action_block }
+	end
+	
+	def empty?
+		@queue.empty? && !@notifying_flag
+	end
+	
+	private
+	
+	def check_thread_ok
+		start_thread unless @thread && @thread.alive?
+	end
+	
+	def start_thread
+		@thread = Thread.new do
+			loop do
+				check_for_events
+			end
+		end
+		@thread.priority = -1 
+	end
+	
+	def check_for_events
+		event, messages = @queue.deq
+		notify( event, *messages )
+	end
+	
+	def notify( event, *messages)
+		@notifying_flag = true
+		watchers_for( event ).each { |action_block|
+			begin 
+				action_block.call(event, *messages)
+			rescue StandardError => err
+				$LOG.warn "ERROR #{err}: #{event} - #{messages.join(' ')}"
+				err.backtrace.each { |s| $stderr.puts s }
+			end 
+		}
+		@notifying_flag = false
+	end
+	
+	def watchers_for( event )
+		watchers[ event ] ||= []
+	end
+	
+	def watchers
+		@watchers ||= {}
+	end
+	
+	def notify_attentive_watchers( event, *messages )
+		attentive_watchers_for( event ).each { |action_block| 
+			begin	
+				action_block.call(event, *messages)
+			rescue StandardError => err
+				$stderr.puts "ERROR #{err}: #{event} - #{messages.join(' ')}"
+				err.backtrace.each { |s| $stderr.puts s }
+			end  
+		}
+	end
+	
+	def attentive_watchers_for( event )
+		attentive_watchers[ event ] ||= []
+	end
+	
+	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
+	# Return the left bit of a string e.g. "String".left(2) => "St"
+  	def left( length ) self.slice( 0, length ) end  
+  
+	# Encode the string so it can be used in urls (code coppied from CGI)
+	def url_encode
+	 self.gsub(/([^a-zA-Z0-9]+)/n) do
+	   '%' + $1.unpack('H2' * $1.size).join('%').upcase
+	 end
+	end
+
+	# Decode a string url encoded so it can be used in urls (code coppied from CGI)
+	def url_decode
+	 self.gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
+	   [$1.delete('%')].pack('H*')
+	 end
+	end  	
+
+  	# Return the first n lines of the string
+  	def first_lines( lines = 1 ) 
+  		self.split("\n")[0,lines].join("\n")
+  	end
+
+	def close_unmatched_html
+		start_tags = self.scan(/<(\w+)[^>\/]*?(?!\/)>/)
+		end_tags = self.scan(/<\/(\w+)[^>\/]*?>/)
+		return self if start_tags.size == end_tags.size
+		missing_tags = start_tags - end_tags
+		text = self.dup
+		missing_tags.each do |tag|
+			text << "</#{tag[0]}>"
+		end
+		text
+	end
+	
+	# Removes punctuation and spaces that can cause problems with page names
+	#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
+	include Enumerable
+	
+	attr_accessor :max_size
+	
+	def initialize( max_size = nil, reverse = false, sort_by = nil )
+		@max_size = max_size
+		@list = Array.new
+		@sort_by = sort_by
+		@reverse = reverse
+	end
+
+	def add( item )
+		remove( item )
+		@list << item
+		sort_items
+		remove_excess_items
+	end
+	
+	def remove( item )
+		@list.delete( item )
+	end
+	
+	def each
+		if @reverse
+			@list.reverse_each { |item| yield item }
+		else
+			@list.each { |item| yield item }
+		end
+	end
+	
+	def empty?; @list.empty? end
+	
+	def include?( item )
+		@list.include?( item )
+	end
+	
+	private 
+	
+	def remove_excess_items
+		return unless @max_size
+		while @list.size > @max_size
+			@list.shift
+		end
+	end
+	
+	def sort_items
+		return unless @sort_by
+		@list = @list.sort_by { |item| item.send( @sort_by ) }
+	end
+end
+
+# Kindly written by Bil Kleb
+class Numeric
+ # similar to  distance_of_time_in_words as found in
+ # actionpack-1.1.0/lib/action_view/helpers/date_helper.rb
+ def to_time_units
+  seconds = self.round
+  case seconds
+   when 0:                                "fraction of a second"
+   when 1:                                "second"
+   when 2..45:                            "#{seconds} seconds"
+   when 46..90:                           "minute"
+   when 91..(60*45):                      "#{(seconds.to_f/60.0).round} minutes"
+   when (60*45)..(60*90):                 "hour"
+   when (60*90)..(60*60*22):              "#{(seconds.to_f/60.0/60.0).round} hours"
+   when (60*60*22)..(60*60*36):           "day"
+   when (60*60*36)..(60*60*24*26):        "#{(seconds.to_f/60.0/60.0/24.0).round} days"
+   when (60*60*24*26)..(60*60*24*45):     "month"
+   when (60*60*24*45)..(60*60*24*30*11):  "#{(seconds.to_f/60.0/60.0/24.0/30.0).round} months"
+   when (60*60*24*30*11)..(60*60*24*500): "year"
+  else                                    "#{(seconds.to_f/60.0/60.0/24.0/365.0).round} years"
+  end
+ end
+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
+	
+	def self.unique_filename( path, filename )
+	    filename.tr!('\\','/') if filename =~ /^[A-Z]:\\/ # File.basename requires / rather than \ which can be a problem with file uploads
+        filename = File.basename( filename ) # Drop all the extra directory information
+        filename.gsub!(/[^A-Za-z0-9._%]/,'') # Drop anything but the basic stuff we trust
+        return filename unless exist?( join( path, filename ) )# Leave as is, if doesn't exist
+		name, counter, extension = basename( filename, '.*'), 1, extname( filename )
+		counter += 1 while exist?( join( path, "#{name}#{counter}#{extension}" ) )
+		return "#{name}#{counter}#{extension}"
+	end
+
+end