Soks 0.0.2 → 0.0.3

data/lib/soks-model.rb

@@ -1,90 +1,122 @@
 # Revision stores changes as a diff against the more recent content version
 class Revision
-	attr_reader :number, :changes, :created_at, :author
+	attr_reader	:number,  :author, :page
+	attr_reader  :changes, :created_on 
+	alias :revised_on :created_on
 	
-	def initialize( number, changes, author )
-		@number, @changes, @author = number, changes, author
-		@created_at = Time.now
+	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 when this revision was created, by recursively applying diffs
-	# to more recent versions.
-	def content( page )
-		$stderr.puts "#{number} #{page}"
-		page.revision( @number + 1 ) ? page.revision( @number + 1 ).previous_content( page ) : page.content
+	# 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
 	end
 	
-	def previous_content( page )
-		content( page ).split("\n").unpatch!(@changes).join("\n")
+	# Recreateds the content of the page BEFORE this revision had been made
+	def previous_content
+		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 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_reader :name, :content, :revisions
+	attr_accessor :name, :content, :revisions
 	attr_accessor :links_from, :links_to, :inserted_into
-
+	alias :to_s	:name
+	
 	# Returns an empty version of itself.
   	def self.empty( name )
-	    empty = self.new( name, "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; "[[Create #{name} (#{self.class}) : /edit/#{name} ]]" end
+	      def textile; "[[#{$MESSAGES[:Create]} #{name} => /edit/#{name} ]]" end
 			def empty?; true; end
 	    end
 	    empty
     end
 
-	def initialize( name, content, author  )
+	def initialize( name )
 		@name, @content, @revisions = name, "", []
 		@links_from, @links_to = [], [] 
-		@inserted_into, @watchers = [], []
-		revise content, author
+		@inserted_into = []
 	end
-	
-	alias :textile :content
-	alias :name_for_index :name
-	alias :to_s	:name
   	
   	# Revises the content of this page, creating a new revision class that stores the changes
-	def revise( content, author )
-		changes = @content.split("\n").diff( content.split("\n") ).map { |changeset| changeset.map { |change| change.to_a } }
-		unless changes.empty?
-			@revisions << Revision.new( @revisions.length, changes, author )
-			@content = content
+	def revise( new_content, author )
+		if the_same_author_recently_revised_this_page( author )
+			changes = changes_between(  previous_content, new_content )
+			@revisions[-1] = Revision.new( self,  @revisions.length, changes , author )
+		else
+			changes = changes_between( @content, new_content )
+			return nil if changes.empty?
+			@revisions << Revision.new( self,  @revisions.length, changes , author ) 
 		end
+		@content = new_content
+		@revisions.last
 	end
 
 	# Returns the content of this page to that of a previous version
 	def rollback( number, author )
-		if number < 0
-			revise( "page deleted", author )
-		else
-			revise( @revisions[ number ].content( self ), author ) 
-		end
+		revise( ( number < 0 ) ? $MESSAGES[:page_deleted] : @revisions[ number ].content, author )
 	end	
 	
-	def revision( number ) 	@revisions[ number ] end
+	def revision( number ) @revisions[ number ] end
 
 	def deleted?
-		( content.strip.downcase == 'page deleted' ) || 
-		( content =~ /^content moved to /i )
+		( content.strip.downcase == $MESSAGES[:page_deleted] ) || 
+		( content =~ /^#{$MESSAGES[:content_moved_to]} /i )
 	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 score; @links_from.size + @links_to.size + @watchers.size end
+	def is_inserted_into( page ) 
+		@inserted_into << page unless @inserted_into.include? page
+	end
 	
-	def <=>( otherpage ) 	self.score <=> otherpage.score end
+	def textile( content = @content ) content end
+		
+	def name_for_index; name.downcase end
 		
-	def watch( person ) 	( @watchers << person ).uniq!		end
-	def watching?( person ) @watchers.include? person 	end
-	def unwatch( person ) 	@watchers.delete( person ) 	end
-	
-	def is_inserted_into( page ) (@inserted_into << page).uniq! end
-
 	# Any unhandled calls are passed onto the latest revision (e.g. author, creation time etc)
-	def method_missing(method_symbol, *args)
-		@revisions.last.send( method_symbol, *args )
-  	end
+	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
+	
+	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
+	
+	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
 
 #Serves as a marker, so ImagePage and AttachmentPage can re-use the same view templates
@@ -92,40 +124,45 @@ class UploadPage < Page
 end
 
 class ImagePage < UploadPage
-  def textile()
+  def textile( content = @content )
   	deleted? ? content : "!#{content}(#{@name})!:/#{@name.url_encode}\n" 	
   end
   
-  def name_for_index; 	@name[ 10..-1].strip	end
+  def name_for_index; 	@name[10..-1].strip.downcase	end
 end
 
 class AttachmentPage < UploadPage 
-  def textile()
+  def textile( content = @content )
   	deleted? ? content :  %Q{"#{@name}":#{content}\n} 	
   end
-  def name_for_index; 	@name[ 9..-1].strip			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 Enumerable
-  
-	def initialize( folder )
-		@folder = folder
-		@pages = Hash.new
-	    @page_classes = [ 
+	include Notify # Will notify any watchers if underlying files change
+	 
+	PAGE_CLASSES = [ 
 	      [ /^picture of/i, ImagePage ],
 	      [ /^attached/i, AttachmentPage ],
 	      [ /.*/, Page ]
 	    ]
-	    load_all_pages_in( folder )
+
+	def initialize( folder )
+		@folder = folder
+		@pages = {}
+		load_all_pages
+		start_watching_files
 	end
 	
 	def page( name )
-	 	@pages[ name.downcase ] || class_for( name ).empty( name )
+	 	page_named( name )|| new_page( name, :empty )
 	end
 	
-	def each
-		@pages.each { |name, page| yield [name, page] unless page.deleted? }
+	def each( exclude_deleted = true )
+		@pages.each { |name, page| yield [name, page] unless exclude_deleted && page.deleted? }
 	end
 	
 	def exists?( name )
@@ -133,76 +170,56 @@ class Wiki
 	end
   
 	def revise( pagename, content, author )
-		mutate( pagename, content, author ) { |page| page.revise( content, author ) }
+		mutate( pagename ) { |page| page.revise( content, author ) }
 	end
 	
 	def rollback( pagename, number, author )
 		mutate( pagename ) { |page| page.rollback( number, author ) }
 	end
 	
-	def watch( pagename, person )
-		mutate( pagename ) { |page| page.watch( person ) }
-	end
-  
-  	def unwatch( pagename, person )
-  		mutate( pagename ) { |page| page.unwatch( person ) }
-  	end
-  	
 	private 
 	
-	def mutate( pagename, content = nil, author = nil ) 
-		page = @pages[ pagename.downcase ]
-		if page
-			yield page
-			save_page page
-		elsif content && author
-			@pages[ pagename.downcase ] = page = class_for( pagename ).new( pagename, content, author)
-			save_page page
-		end
-	end
-	
-	def load_all_pages_in( folder )
-		Dir.foreach( folder ) do |filename|
-			$stderr.puts "Loading #{filename}"
-			load_page( filename )  if filename =~ /\.textile$/
-		end
-		$stderr.puts "All loaded"
+	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
 	end
-	
-	def load_page( filename )
-		if File.exists? File.join( @folder, filename )		
-			page_name = File.basename( filename, '.*').url_decode
-			content = IO.readlines( File.join( @folder, filename ) ).join
-			revisions = load_revisions_for( filename )
-			
-			page = class_for( page_name ).new( page_name, content, 'imported' )
-			page.revisions.replace( revisions ) if revisions
-			@pages[ page.name.downcase ] = page
+
+	def new_page( name, initializer = :new )
+		PAGE_CLASSES.each do |regex,klass|
+			return klass.send( initializer, name) if name =~ regex
 		end
 	end
-	
-	def load_revisions_for( page_filename )
-		revision_filename = "#{File.basename( page_filename, '.*')}.marshal"
-		if File.exists? File.join( @folder, revision_filename )
-			File.open( File.join( @folder, revision_filename ) ) do |file|
-				return Marshal.load( file )
-			end 
+		
+	def mutate( pagename )
+		didexist = exists? pagename
+		check_disk_for_updated_page pagename
+		page = page_named( pagename ) || new_page( pagename )
+		revision = yield page
+		if revision
+			save page
+			notify :page_revised, page, revision
+			if page.deleted?
+				notify :page_deleted, page, revision
+			elsif !didexist
+				notify :page_created, page, revision
+			end
 		end
-		return nil
 	end
 	
-	def save_page( page )
-		File.open( "#{filename_for( page )}.textile", 'w' ) { |file| file.puts page.content }
-		File.open( "#{filename_for( page )}.marshal", 'w' ) { |file| Marshal.dump( page.revisions, file ) }
+	def add_page_to_index( page )
+		@pages[ page.name.downcase ] = page
+		page
 	end
 	
-	def filename_for( page )
-		File.join( @folder, "#{page.name.url_encode}" )
-	end
-	
-	def class_for( name )
-		@page_classes.each do |regex,klass|
-			return klass if name =~ regex
-		end
+	def page_named( pagename )
+		@pages[ pagename.downcase ]
 	end
+
 end
+
+

data/lib/soks-servlet.rb

@@ -1,40 +1,69 @@
 #!/usr/local/bin/ruby
 require 'authenticators'
+require 'yaml'
 
-Thread.abort_on_exception = true
-Socket.do_not_reverse_lookup = true
+$SETTINGS = {
+	:name => 'test',
+	:description => 'A Soks Wiki',
+	:root_directory => 'soks-wiki',
+	:check_files_every => 60, # Seconds
+	:url => 'http://localhost:8000',
+	:port => 8000,
+	:dont_frame_templates => ['print','rss'],
+	:strict_html_removal => true, # True to prevent users from adding html.
+	:authenticators => [ [ %r{/(view|rss|print|find|meta)/.*}, WEBrick::HTTPAuth::NoAuthenticationRequired.new ],
+								# [ %r{/upload/.*}, WEBrick::HTTPAuth::NotPermitted.new ],
+								# [ %r{/(edit|save)/home page}, WEBrick::HTTPAuth::SiteWidePassword.new('password','You need to enter the site wide password to edit the home page') ],
+								# [ %r{/(view|edit|save)/private.*},WEBrick::HTTPAuth::BasicAuth.new( :UserDB => htpasswd, :Realm => realm ) ], # See webrick documentation
+								[ %r{.*}, WEBrick::HTTPAuth::AskForUserName.new( 'No password, just enter a name') ]						
+							 ] 
+}
 
 class WikiServlet < WEBrick::HTTPServlet::AbstractServlet
 
-	def initialize( server, wiki, name, wikiurl, authenticator = nil, no_authentication_for= [] )
-		@server, @wiki, @name, @wikiurl, @authenticator, @no_authentication_for  = server, wiki, name, wikiurl, authenticator, no_authentication_for
+	def initialize( server, wiki, settings )
+		@server, @wiki, @name, @wikiurl, @authenticators = server, wiki, settings[:name] , settings[:url] , settings[:authenticators]
 	end
 		
 	def service( request, response )
-		leadingslash, verb, *pagename = request.path.split('/')
-		redirect( response, "Home Page" ) unless verb
-		if verb == 'find' # The search term is from a form
-			pagename = [ request.query['regex'] ]
-		elsif pagename.empty? # There was no verb. Use the pagename instead
-			verb, pagename = 'view', [ verb ]
+		case request.path
+		when /\/(\w+?)\/(.+)/
+			verb, pagename = $1, $2
+			authenticate request, response	
+			if self.respond_to?( "do#{verb.capitalize}" )
+				self.send( "do#{verb.capitalize}", request, response, pagename, request.user )
+			else
+				response.body = @wiki.view( pagename, verb, request.user )
+			end
+		when /\/(.+)/	; redirect( response, $1, 'view' )	 # No command given
+		when "/"			; redirect( response, "Home Page", 'view' ) # No page or command given
 		end
-		@authenticator.authenticate( request, response ) unless @no_authentication_for.include? verb
-		
-		if self.respond_to?( "do#{verb.capitalize}" )
-			self.send( "do#{verb.capitalize}", request, response, pagename.join('/'), request.user )
-		else
-			response.body = @wiki.view( pagename.join('/'), verb, request.user )
-		end			
+				
 		response['Content-Type'] ||= "text/html"
+		response['Cache-control'] ||= 'no-cache'
+		response['Pragma'] ||= 'no-cache'
 	end 
 	
+	def authenticate( request, response )
+		@authenticators.each do |path_regex,authenticator|
+			if request.path.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
+	
+	def doWiki( request, response, pagename, person )
+		redirect( response, pagename.gsub(/([a-z])([A-Z])/,'\1 \2') )
+	end
 
 	def doFind( request, response, pagename, person ) 
-		response.body = @wiki.find( pagename )	
+		response.body = @wiki.find( request.query['regex'] )	
 	end
 
 	def doSave( request, response, pagename, person )
@@ -75,7 +104,7 @@ class WikiServlet < WEBrick::HTTPServlet::AbstractServlet
 	def upload( filename, filedata )
 		path = "#{$SETTINGS[:root_directory]}/attachment/"
 		filename = unique_filename( path ,filename )
-		File.open( File.join( path, filename ), 'w' ) { |file| filedata.list.each { |data| file << data } }
+		File.open( File.join( path, filename ), 'wb' ) { |file| filedata.list.each { |data| file << data } }
 		"/attachment/#{filename}"
 	end
 	
@@ -93,31 +122,21 @@ class WikiServlet < WEBrick::HTTPServlet::AbstractServlet
 	end
 end
 
-$SETTINGS = {
-	:name => 'test',
-	:description => 'A Soks Wiki',
-	:root_directory => 'wiki',
-	:url => 'http://localhost:8000',
-	:port => 8000,
-	:authenticator => WEBrick::HTTPAuth::NotAuthentication.new( 'No password, just enter a name'),
-	:dont_authenticate => ['view','rss'] 
-}
-
-
-
 def start_wiki( settings = {}, &automatic_agents )
-	$SETTINGS.merge! settings
 
+	$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, view ) do |block, view|
-		block.call( view )
+	Thread.new( automatic_agents, wiki, view ) do |block, wiki, view|
+		block.call( wiki, view )
 	end.priority = -2
 	
 	server = WEBrick::HTTPServer.new( { :Port => $SETTINGS[:port] } )
 	server.mount("/attachment", WEBrick::HTTPServlet::FileHandler, "#{ $SETTINGS[:root_directory] }/attachment", true)
-	server.mount("/", WikiServlet, view, $SETTINGS[:name] , $SETTINGS[:url] , $SETTINGS[:authenticator] , $SETTINGS[:dont_authenticate]  )
+	server.mount("/", WikiServlet, view, $SETTINGS  )
 
 	trap("INT") { server.shutdown }