Soks 0.0.2 → 0.0.3

data/lib/soks-storage.rb

@@ -0,0 +1,134 @@
+module WikiFlatFileStore
+
+	CONTENT_EXTENSION = '.textile'
+	REVISIONS_EXTENSION = '.yaml'
+	DEFAULT_AUTHOR = 'AutomaticImport' 
+
+	def save( page )
+		add_page_to_index( page )
+		save_content( page )
+		save_revisions( page )
+	end
+
+	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|
+			page = page_named( pagename )
+		
+			if page && !File.exists?( filename_for_content( pagename ) )
+				@pages[ page.name.downcase ] = nil
+				notify :page_revised, page, page.revisions.last
+				notify :page_deleted, page, page.revisions.last
+				next
+			end
+			unless page
+				page = load_page( filename_for_content( pagename ) )
+				notify :page_revised, page, page.revisions.last
+				notify :page_created, page, page.revisions.last
+				next
+			end
+			if check_disk_for_updated_page pagename
+				page = page_named( pagename )
+				notify :page_revised, page, page.revisions.last
+			end
+		end
+	end
+	
+	def load_page( filename )
+		page = new_page( page_name_for( filename ) )
+		page.revisions = load_revisions( page )
+		content = load_content( page )
+		
+		if page_named( page.name ) # Save having to find this out again
+			page.inserted_into = page_named( page.name ).inserted_into
+		end
+		
+		if page.revisions.empty? # There is a textile file but no array file
+			page.revise(content, DEFAULT_AUTHOR )
+			save_revisions( page )
+		elsif 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( content, DEFAULT_AUTHOR )
+			save_revisions( page )
+		else # The textile file and the array file are in sync.
+			page.content = content
+		end
+		
+		add_page_to_index( page )
+		page
+	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 = []
+		File.open( filename_for_revisions( page.name ) ) { |file| 
+			YAML.each_document( file ) { |array|
+					revisions[ array[0] ] = Revision.new( page, *array ) 
+			} 
+		}
+		revisions.each_with_index { |r,i| $stderr.puts "#{page.name} missing revision #{i}" unless r }
+		revisions
+	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 )
+		$stderr.puts "Saving revisions for #{page.name}"
+		File.open(filename_for_revisions( page.name ), 'a' ) { |file| 
+			YAML.dump( page.revisions.last.to_a, file )
+			file.puts
+		}
+	end
+	
+	def check_disk_for_updated_page( pagename )
+		return unless $SETTINGS[:check_files_every] # We don't care about file changes 
+		filename = filename_for_content( pagename )
+		return nil 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 ( page_named(pagename).revised_on < File.ctime( filename ) ) # File is newer on disk
+		return nil
+	end
+
+	def content_newer_than_revisions?( page )
+		page_file = filename_for_content page.name
+		revision_file = filename_for_revisions page.name
+		File.ctime(page_file) > File.ctime(revision_file)
+	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), basename.url_decode.url_encode) +  File.extname( filename) 
+			File.rename(filename, new_name )
+		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

@@ -1,32 +1,76 @@
+# 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)
+		self.event_queue.event( event, messages )
+	end
+	
+	def event_queue
+		@event_queue ||= EventQueue.new
+	end
+end
+
 class EventQueue
 
 	def initialize
 		@queue = Queue.new
-		Thread.new do
-			loop do
-				check_for_events
-			end
-		end.priority = -1 
+		start_thread
 	end
 	
 	def event( event, messages )
+		check_thread_ok
 		@queue.enq [ event, messages ]
+		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
+	
 	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)
-		watchers_for( event ).each { |action_block| 
-			action_block.call(event, *messages) 
+		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
 	
@@ -37,31 +81,37 @@ class EventQueue
 	def watchers
 		@watchers ||= {}
 	end
-end
-
-# This is a bit like observable, but for events
-module Notify
 	
-	def watch_for( *events , &action_block )
-		self.event_queue.watch_for( events, action_block )
+	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 notify( event, *messages)
-		self.event_queue.event( event, messages )
+	def attentive_watchers_for( event )
+		attentive_watchers[ event ] ||= []
 	end
 	
-	def event_queue
-		@event_queue ||= EventQueue.new
+	def attentive_watchers
+		@attentive_watchers ||= {}
 	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
+	 self.gsub(/([^a-zA-Z0-9]+)/n) do
 	   '%' + $1.unpack('H2' * $1.size).join('%').upcase
 	 end.tr(' ', '+')	
 	end
@@ -77,4 +127,64 @@ class String
   	def first_lines( lines = 1 ) 
   		self.split("\n")[0,lines].join("\n")
   	end
-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
+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
+	
+	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

data/lib/soks-view.rb

@@ -15,13 +15,11 @@ class Links
 		linksto = Array.new
 		@links.each do | pagefrom, pagesto |
 			next if pagefrom == thispage
-			unless [ "site index", "recent changes to this site" ].include? pagefrom.name.downcase
-				if pagesto.include? thispage  
-					linksto << pagefrom
-				end
-			end
+			next if [ "site index", "recent changes to this site" ].include? pagefrom.name.downcase
+			next if linksto.include? pagefrom
+			linksto << pagefrom if pagesto.include? thispage 
 		end
-		return linksto.uniq.sort
+		return linksto.sort
 	end
 end
 
@@ -30,8 +28,8 @@ end
 # the first thing it can, rather than skipping a shorter match to enable
 # a longer one that starts at a later point in the text
 class RollingMatch
-	WORD_REGEX = /^\w*/
-	SPACE_REGEX = /^\W*/
+	WORD_REGEX = /\w*/
+	SPACE_REGEX = /\W*/
 	IGNORE_CASE = true
 
 	def initialize
@@ -117,29 +115,32 @@ if RedCloth::VERSION == '2.0.11'
         
         @urlrefs = {}
         @shelf = []
-	     @internal_links_from_page = [] # NEW
+	    @internal_links_from_page = [] # NEW
 	     
-		  insert_sub_strings text	# NEW
-		  
-        incoming_entities text 
-        ## encode_entities text 
-        ## fix_entities text 
-        clean_white_space text 
-
-        get_refs text 
+		insert_sub_strings text	# NEW
+		
+		shelve_divs_and_spans text # NEW  
+		
+       clean_white_space text 
 
         no_textile text
 		  
 		  pre_list = rip_offtags text # NEW wasteful to duplicate, but reduces overloading 		
 		  hide_textile_links text   # NEW
 		  hide_textile_image_tags text # NEW
-		  inline_soks_external_link text # NEW
 		  inline_soks_bracketed_link text # NEW 
+		  inline_soks_external_link text # NEW
 		  inline_soks_automatic_link text # NEW
 		  @wiki.links.set_links_from( @page, @internal_links_from_page ) # NEW
 		  unhide_textile text # NEW  
 		  smooth_offtags text, pre_list # NEW wasteful to duplicate
 		
+		incoming_entities text 
+        ## encode_entities text 
+        ## fix_entities text 
+        
+        get_refs text 
+		
         inline text
 
         unless @lite
@@ -153,8 +154,12 @@ if RedCloth::VERSION == '2.0.11'
         text.gsub!( /x%x%/, '&#38;' )
         text.gsub!( /<br \/>/, "<br />\n" )
         text.strip!
+
+		clean_html text if $SETTINGS[:strict_html_removal]
+		
         text
 	end
+	
 end
 
 if RedCloth::VERSION == '3.0.1'	
@@ -173,7 +178,7 @@ if RedCloth::VERSION == '3.0.1'
         markdown_rules = [:refs_markdown, :block_markdown_setext, :block_markdown_atx, :block_markdown_rule,
                           :block_markdown_bq, :block_markdown_lists, 
                           :inline_markdown_reflink, :inline_markdown_link]
-        soks_rules = [ :hide_textile_links, :hide_textile_image_tags, :inline_soks_external_link, :inline_soks_bracketed_link, :inline_soks_automatic_link, :unhide_textile ]
+        soks_rules = [ :hide_textile_links, :hide_textile_image_tags, :inline_soks_bracketed_link, :inline_soks_external_link, :inline_soks_automatic_link, :unhide_textile ]
         @rules = rules.collect do |rule|
             case rule
             when :markdown
@@ -188,7 +193,7 @@ if RedCloth::VERSION == '3.0.1'
         end.flatten
 
 		# insert sub pages
-		insert_sub_strings text
+			insert_sub_strings text
 
         # standard clean up
         incoming_entities text 
@@ -208,11 +213,81 @@ if RedCloth::VERSION == '3.0.1'
         text.gsub!( /<\/?notextile>/, '' )
         text.gsub!( /x%x%/, '&#38;' )
         text.strip!
+ 
+		  clean_html text
+
         text
 	end
 end	
 
 	private
+
+	def shelve_divs_and_spans( text )
+		text.gsub!(/<\/+(div|span).*?>/) { |m| shelve m }
+	end 
+
+    ## Dictionary describing allowable HTML
+    ## tags and attributes.
+    BASIC_TAGS = {
+        'a' => ['href', 'title'],
+        'img' => ['src', 'alt', 'title'],
+        'br' => [],
+        'i' => nil,
+        'u' => nil,
+        'b' => nil,
+        'pre' => nil,
+        'kbd' => nil,
+        'code' => ['lang'],
+        'cite' => nil,
+        'strong' => nil,
+        'em' => nil,
+        'ins' => nil,
+        'sup' => nil,
+        'sub' => nil,
+        'del' => nil,
+        'table' => [ 'class', 'style' ],
+        'tr' => [ 'class', 'style' ],
+        'td' => [ 'class', 'style' ],
+        'th' => [ 'class', 'style' ],
+        'ol' => nil,
+        'ul' => nil,
+        'li' => nil,
+        'p' => [ 'class', 'style' ],
+        'h1' => nil,
+        'h2' => nil,
+        'h3' => nil,
+        'h4' => nil,
+        'h5' => nil,
+        'h6' => nil,
+        'blockquote' => ['cite'],
+		  'div' => [ 'class', 'id', 'style' ],
+		  'span' => [ 'class', 'id','style'],
+    }
+
+    ## Method which cleans the String of HTML tags
+    ## and attributes outside of the allowed list.
+    def clean_html( text, tags = BASIC_TAGS )
+        text.gsub!( /<(\/*)(\w+)([^>\/]*?)( *\/*)>/ ) do
+            raw = $~
+            tag = raw[2].downcase
+            if tags.has_key? tag
+                pcs = [tag]
+                tags[tag].each do |prop|
+                    ['"', "'", ''].each do |q|
+                        q2 = ( q != '' ? q : '\s' )
+                        if raw[3] =~ /#{prop}\s*=\s*#{q}([^#{q2}]+)#{q}/i
+                            pcs << "#{prop}=\"#{$1.gsub('"', '\\"')}\"" 
+                            break
+                        end
+                    end
+                end if tags[tag]
+                "<#{raw[1]}#{pcs.join " "}#{raw[4]}>" 
+            else
+                " " 
+            end
+        end
+		text
+   end
 	
 	def insert_sub_strings( text, count = 0 )
 	  return text if count > 5 # Stops us getting locked into a cycle if people mess up the insert
@@ -228,21 +303,21 @@ end
 	end		
 
 	def inline_soks_external_link( text )
-	    text.gsub!(/http:\/\/[^ \n<]+/i) 			{ |m| link m }
-	    text.gsub!(/https:\/\/[^ \n<]+/i) 			{ |m| link m }
-	    text.gsub!(/www.[^ \n<]*/i) 				{ |m| link( "http://#{m}", m) }
+	    text.gsub!(/http:\/\/[^ \n<]+/i) 				{ |m| link m }
+	    text.gsub!(/https:\/\/[^ \n<]+/i) 				{ |m| link m }
+	    text.gsub!(/www\.[^ \n<]*/i) 					{ |m| link( "http://#{m}", m) }
 	    text.gsub!(/[A-Za-z0-9.]+?@[A-Za-z0-9.]+/)	{ |m| link( "mailto:#{m}", m) }
 	end
 		
 	def inline_soks_bracketed_link( text )
-		text.gsub!(/\[\[([^\]]+)\]\]/) do |m| 
-      	title, *pagename = m[2..-3].split(':').map { |t| t.strip }
-     		pagename = pagename.empty? ? title : pagename.join(':')
+		text.gsub!(/\[\[\s*(.*?)\s*(|=>\s*(.*?)\s*)\]\]/) do |m| 
+     		title, pagename = $1, $3
+			pagename ||= title
 			case pagename
-			when /^www./i 						; link("http://#{pagename}", title )
+			when /^www\./i 							; link("http://#{pagename}", title )
 			when /[A-Za-z0-9.]+?@[A-Za-z0-9.]+/ ; link("mailto:#{pagename}",title)
-			when /^http/i 						; link(pagename,title)
-			else								; wiki_link( pagename, title )
+			when /^http:\/\//i 						; link(pagename,title)
+			else											; wiki_link( pagename, title )
 			end
 		end
 	end
@@ -256,17 +331,28 @@ end
 		text.replace( linkedtext )
 	end
 	
-	def wiki_link( pagename, title, css = nil )
+	def wiki_link( pagename, title, css_class = nil )
 		if @wiki.exists? pagename
 			@internal_links_from_page << @wiki.page( pagename )
-			link(pagename,title, css || '' )
-		else
-			link(pagename,title, css || 'missing')
+			css_class ||= ''
 		end
+		link(url_encode_pagename( pagename ),title, css_class || 'missing')
+	end
+	
+	def link( url, title = url, css_class = '' )
+		shelve "<a href='#{url}' class='#{css_class}'>#{title}</a>"
 	end
 	
-	def link( url, title = url, css = '' )
-		shelve "<a href='#{url}' class='#{css}'>#{title}</a>"
+	# This makes sure punctuation can be used in the name of the page
+	# by url encoding anything that isn't a letter of a number.
+	# The complexity is to check that a command hasn't been embedded inside
+	# a pagename (e.g. /edit/home page ) in which case the command should not
+	# be encoded. 
+	def url_encode_pagename( pagename )
+		if pagename =~ /\/(\w+)\/(.*)/
+			return "/#{$1}/#{$2.url_encode}"
+		end
+		return pagename.url_encode
 	end
 	
 	def hide_textile_image_tags( text )
@@ -276,7 +362,6 @@ end
 		text
 	end
 	
-	
 	def hide_textile_links( text )
 		text.gsub!( LINK_RE ) do |match|
 			hide_textile match
@@ -303,13 +388,13 @@ end
 end
 
 class View
-	include Notify
 	attr_reader :rollingmatch, :links
 
 	def initialize( wiki, name )
 		@wikiname = name
 		@rollingmatch, @links, @redcloth_cache, @erb_cache = RollingMatch.new, Links.new, Hash.new, Hash.new
 		@wiki = wiki
+		wiki.watch_attentively_for( :page_revised ) { |event,page,revision| refresh_redcloth( page ) }
 	end
 
 	def view( pagename, view = 'view', person = nil )
@@ -325,6 +410,7 @@ class View
 	
 	def find( pagename )
 		return view( pagename ) if @wiki.exists?( pagename )
+		view = 'find'
 		search_term = /#{pagename}/i
 		title_results = @wiki.select { |name,page| name=~ search_term }
 		text_results = @wiki.select { |name,page| page.content=~ search_term }
@@ -334,42 +420,30 @@ class View
 	end
 		
 	def revise( pagename, content, person, newpagename = pagename )
-		if @wiki.exists? pagename
-			unless newpagename == pagename
-				mutate( pagename ) { @wiki.revise( pagename, "Content moved to [[#{newpagename}]]", person ) }
-				mutate( newpagename ) { @wiki.revise( newpagename, "Content moved from [[#{pagename}]]", person ) }
-			end
+		if @wiki.exists?( pagename ) && (newpagename != pagename)
+			@wiki.revise( pagename, "#{$MESSAGES[:content_moved_to]} [[#{newpagename}]]", person )
+			@wiki.revise( newpagename, "#{$MESSAGES[:content_moved_from]} [[#{pagename}]]", 'AutomaticPageMover' )
+			@wiki.revise( newpagename, content, person )
+		else
+			@wiki.revise( newpagename, content, person )
 		end
-		mutate( newpagename ) { @wiki.revise( newpagename, content, person ) }	
+		
 	end
 	
 	def move( oldpagename, person, newpagename )
 		unless newpagename == oldpagename
-			mutate( newpagename ) { @wiki.revise( newpagename, "Content moved from [[#{pagename}]]", person ) }
-			mutate( newpagename ) { @wiki.revise( newpagename, @wiki.page( oldpagename ).content, person ) }
-			mutate( oldpagename ) { @wiki.revise( oldpagename, "Content moved to [[#{newpagename}]]", person ) }
+			@wiki.revise( newpagename, "#{$MESSAGES[:content_moved_from]} [[#{pagename}]]", 'AutomaticPageMover')
+			@wiki.revise( newpagename, @wiki.page( oldpagename ).content, person)
+			@wiki.revise( oldpagename, "#{$MESSAGES[:content_moved_to]} [[#{newpagename}]]", person)
 		end
 	end
 	
 	def rollback( pagename, revision, person )
-		mutate( pagename ) { @wiki.rollback( pagename, revision, person ) }
+		@wiki.rollback( pagename, revision, person )
 	end
 	
 	def delete( pagename, person )
-		mutate( pagename ) { @wiki.revise( pagename, 'Page deleted', person ) }
-	end
-	
-	def mutate( pagename )
-		didexist = @wiki.exists? pagename
-		yield
-		page = @wiki.page( pagename )
-		clear_redcloth_cache( page )
-		notify :page_revised, page, page.revisions.last
-		if page.deleted?
-			notify :page_deleted, page
-		elsif !didexist
-			notify :page_created, page 
-		end
+		@wiki.revise( pagename, $MESSAGES[:page_deleted], person )
 	end
 		
 	def refresh_redcloth( page )
@@ -403,7 +477,7 @@ class View
   	def path_for( klass, view ) "#{$SETTINGS[:root_directory]}/views/#{klass}_#{view}.rhtml" end
 	
 	def should_frame?( view )
-		return true unless ['print','rss'].include? view.downcase
+		return true unless $SETTINGS[:dont_frame_templates].include? view.downcase
 	end
 	
 	def frame_erb