Soks 0.0.2

data/lib/soks-servlet.rb

@@ -0,0 +1,125 @@
+#!/usr/local/bin/ruby
+require 'authenticators'
+
+Thread.abort_on_exception = true
+Socket.do_not_reverse_lookup = true
+
+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
+	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 ]
+		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"
+	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 doFind( request, response, pagename, person ) 
+		response.body = @wiki.find( pagename )	
+	end
+
+	def doSave( request, response, pagename, person )
+		content = request.query["content"].to_s
+		newpagename = request.query["titleprefix"].to_s + request.query["newtitle"].to_s
+		@wiki.revise( pagename, content.gsub(/\r\n/,"\n"), person, newpagename) if content
+		redirect( response, newpagename )
+	end
+	
+	def doRollback( request, response, pagename, person )
+		revision = request.query['revision'] ? request.query['revision'].to_i : nil
+		@wiki.rollback( pagename, revision, person ) if revision
+		redirect( response, pagename )
+	end
+	
+	def doDelete( request, response, pagename, person )
+		@wiki.delete( pagename, person )
+		redirect( response, pagename )
+	end
+	
+	def doUpload( request, response, pagename, person )
+		newpagename = request.query["titleprefix"].to_s + request.query["newtitle"].to_s
+		unless request.query['file'] == ""
+			@wiki.revise( pagename, upload( request.query['file'].filename[/[0-9A-Za-z.]*$/], request.query['file'] ) , person, newpagename )
+		else
+			@wiki.move( pagename, person, newpagename )
+		end
+		redirect( response, newpagename )
+	end
+	
+	def doRss( request, response, pagename, person )
+		response.body = @wiki.view( pagename, 'rss', person )
+		response["Content-Type"] = "text/xml"
+	end
+
+	private
+		
+	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 } }
+		"/attachment/#{filename}"
+	end
+	
+	def unique_filename( path, filename )
+		bits = filename.split(/\./)
+		while File.exist? File.join( path, filename )
+			if bits.length >= 1
+				bits[-2].succ!
+			else
+				bits[0].succ!
+			end
+			filename = bits.join('.')
+		end
+		filename
+	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
+
+	wiki = Wiki.new( "#{$SETTINGS[:root_directory]}/content" )
+	view = View.new( wiki, $SETTINGS[:name] )
+
+	Thread.new( automatic_agents, view ) do |block, view|
+		block.call( 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]  )
+
+	trap("INT") { server.shutdown }
+
+	server.start
+end

data/lib/soks-utils.rb

@@ -0,0 +1,80 @@
+class EventQueue
+
+	def initialize
+		@queue = Queue.new
+		Thread.new do
+			loop do
+				check_for_events
+			end
+		end.priority = -1 
+	end
+	
+	def event( event, messages )
+		@queue.enq [ event, messages ]
+	end
+	
+	def watch_for( events , action_block )
+		events.each { |event| watchers_for(event) << action_block }
+	end
+	
+	private
+	
+	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) 
+		}
+	end
+	
+	def watchers_for( event )
+		watchers[ event ] ||= []
+	end
+	
+	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 )
+	end
+	
+	def notify( event, *messages)
+		self.event_queue.event( event, messages )
+	end
+	
+	def event_queue
+		@event_queue ||= EventQueue.new
+	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.tr(' ', '+')	
+	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
+end

data/lib/soks-view.rb

@@ -0,0 +1,424 @@
+class Links
+	def initialize
+		@links = Hash.new
+	end
+	
+	def links_from( page ) ; return @links[ page ] ; end
+	
+	def set_links_from( page, linkarray )
+		page.links_from = @links[ page ] = linkarray.uniq
+		page.links_to = links_to( page )
+		page.links_from.each { |linked| linked.links_to = links_to( linked ) }
+	end
+	
+	def links_to( thispage )
+		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
+		end
+		return linksto.uniq.sort
+	end
+end
+
+# This class matches against a text finding the longest matches it can.
+# Note that it isn't that sophisticated, and will tend to match
+# 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*/
+	IGNORE_CASE = true
+
+	def initialize
+		@firstwords, @matches = Hash.new, Hash.new
+	end
+	
+	def []( title ) @matches[ lower_case(title) ] end
+	alias :object_for :[]
+	
+	def delete( title ) 
+		@matches.delete( title )
+	end
+	
+	# Use this to add a string to match and an associated object to return
+	# if an object is matched.
+	def []=( title, object )
+		@matches[lower_case(title)] = object
+		unless lengths_for_first_word_of( title ).include? title.length
+			(lengths_for_first_word_of( title ) << title.length).sort!
+		end
+	end
+  	
+  	# This returns the longest match that starts with the first word in the text
+	def longest_match( text, *dont_match )
+		lengths_for_first_word_of( text ).reverse_each do |length|
+			break if length > text.length
+			if object_for(text.left(length)) && !dont_match.include?( lower_case( text.left(length) ) )
+      			return text.left(length)
+      		end
+    	end
+		nil	
+	end
+	
+	# This iterates through the text returning the longest matches 
+	def rolling_match( text, *dont_match )
+		text = text.dup
+		skipped_text = ""
+		until text.empty?
+			matching_title = longest_match( text, *dont_match )
+			if matching_title
+				yield skipped_text, matching_title, object_for( matching_title )
+				text.slice!( 0, matching_title.length ) # Skip to the end of the matched bit
+				skipped_text = text.slice!( SPACE_REGEX ) # Skip to the end of the next space
+			else
+				skipped_text << text.slice!( WORD_REGEX ) << text.slice!( SPACE_REGEX ) # Skip to the begining of the next word
+			end
+		end
+		yield skipped_text, nil, nil	
+	end
+  
+	private
+	  
+	def lengths_for_first_word_of(title)
+	    @firstwords[ lower_case( title ).slice( WORD_REGEX ) ] ||= Array.new
+	end
+	  
+	def lower_case( text )
+	    IGNORE_CASE ? text.downcase : text
+	end  
+end
+
+# This adds some extra match types to (a bodged version of) RedCloth
+# 
+# Specifically:
+# * Inserting other pages
+# * Square bracketed wiki links 
+# * Automaticlly links anytime the title of another page appears in the text
+# * Automatically links things that look like email addresses and urls
+class WikiRedCloth < RedCloth
+	def initialize( wiki, page, string, restrictions = [] )
+		super(string, restrictions)
+		@wiki, @page = wiki, page
+		@rules = [ :soks, :textile ]
+	end
+	
+if RedCloth::VERSION == '2.0.11'	
+	def to_html( lite = nil )
+				
+        @lite = lite unless lite.nil?
+
+        # make our working copy
+        text = self.dup
+        
+        @urlrefs = {}
+        @shelf = []
+	     @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 
+
+        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_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
+		
+        inline text
+
+        unless @lite
+            fold text
+            block text
+        end
+
+        retrieve text
+
+        text.gsub!( /<\/?notextile>/, '' )
+        text.gsub!( /x%x%/, '&#38;' )
+        text.gsub!( /<br \/>/, "<br />\n" )
+        text.strip!
+        text
+	end
+end
+
+if RedCloth::VERSION == '3.0.1'	
+	def to_html( *rules )
+	 	rules = @rules if rules.empty?
+        # make our working copy
+        text = self.dup
+        
+        @urlrefs = {}
+        @shelf = []
+        @internal_links_from_page = []
+        
+        textile_rules = [:refs_textile, :block_textile_table, :block_textile_lists,
+                         :block_textile_prefix, :inline_textile_image, :inline_textile_link,
+                         :inline_textile_code, :inline_textile_glyphs, :inline_textile_span]
+        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 ]
+        @rules = rules.collect do |rule|
+            case rule
+            when :markdown
+                markdown_rules
+            when :textile
+                textile_rules
+            when :soks
+            	soks_rules
+            else
+                rule
+            end
+        end.flatten
+
+		# insert sub pages
+		insert_sub_strings text
+
+        # standard clean up
+        incoming_entities text 
+        clean_white_space text 
+
+        # start processor
+        pre_list = rip_offtags text
+        refs text
+        blocks text
+        inline text
+        smooth_offtags text, pre_list
+
+        retrieve text
+        
+        @wiki.links.set_links_from( @page, @internal_links_from_page )
+
+        text.gsub!( /<\/?notextile>/, '' )
+        text.gsub!( /x%x%/, '&#38;' )
+        text.strip!
+        text
+	end
+end	
+
+	private
+	
+	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
+	  text.gsub!(/\[\[\s*insert (.+?)\]\]/i) do |m|
+	  	inserted_page = @wiki.page( $1.to_s.strip )
+	  	if @wiki.exists? inserted_page.name
+			@internal_links_from_page << inserted_page
+		  	inserted_page.is_inserted_into( @page )
+		 end
+		insert_sub_strings( "#{inserted_page.textile}\n", count + 1 ) 
+	  end
+	  "\n\n#{text}\n\n"
+	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!(/[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(':')
+			case pagename
+			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 )
+			end
+		end
+	end
+       
+  def inline_soks_automatic_link( text )	
+		linkedtext = ""
+		@wiki.rollingmatch.rolling_match( text, @page.name.downcase ) do |skip, title, page|
+			linkedtext << skip
+			linkedtext << wiki_link( page.name, title, 'automatic' ) if title
+		end
+		text.replace( linkedtext )
+	end
+	
+	def wiki_link( pagename, title, css = nil )
+		if @wiki.exists? pagename
+			@internal_links_from_page << @wiki.page( pagename )
+			link(pagename,title, css || '' )
+		else
+			link(pagename,title, css || 'missing')
+		end
+	end
+	
+	def link( url, title = url, css = '' )
+		shelve "<a href='#{url}' class='#{css}'>#{title}</a>"
+	end
+	
+	def hide_textile_image_tags( text )
+		text.gsub!( IMAGE_RE ) do |match|
+			hide_textile match
+		end
+		text
+	end
+	
+	
+	def hide_textile_links( text )
+		text.gsub!( LINK_RE ) do |match|
+			hide_textile match
+		end
+		text
+	end
+	
+	def unhide_textile( text )
+		hidden_textile.each_with_index do |r, i|
+         text.gsub!( " <$%#{ i + 1 }%$> ", r )
+      end
+		text
+	end
+	
+	def hide_textile( text )
+		hidden_textile << text
+		" <$%#{hidden_textile.length}%$> "
+	end
+	
+	def hidden_textile
+		@hidden_textile_links ||= []
+	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
+	end
+
+	def view( pagename, view = 'view', person = nil )
+		page = @wiki.page pagename
+	   renderedview = redcloth( page )
+		content_of_page = html( page.class, view, binding )
+		if should_frame? view 
+			frame_erb.result binding
+		else
+			content_of_page
+		end
+	end
+	
+	def find( pagename )
+		return view( pagename ) if @wiki.exists?( pagename )
+		search_term = /#{pagename}/i
+		title_results = @wiki.select { |name,page| name=~ search_term }
+		text_results = @wiki.select { |name,page| page.content=~ search_term }
+		content_of_page = html( Page, 'search_results', binding )
+		page = nil
+		frame_erb.result binding	
+	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
+		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 ) }
+		end
+	end
+	
+	def rollback( pagename, revision, person )
+		mutate( pagename ) { @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
+	end
+		
+	def refresh_redcloth( page )
+		$stderr.puts "Refreshing #{page}"
+		clear_redcloth_cache( page )
+		redcloth( page )
+	end
+	
+	def redcloth( page )
+		@redcloth_cache[page] = "" if page.textile.strip == ""
+		@redcloth_cache[ page ] ||= WikiRedCloth.new( self, page, page.textile ).to_html
+	end
+	
+	def clear_redcloth_cache( page = :all_pages )
+		( page == :all_pages ) ? @redcloth_cache.clear : @redcloth_cache.delete( page )
+	end
+	
+	def html( klass, view, _binding )
+		#@erb_cache.clear
+		( @erb_cache[ path_for( klass, view ) ] ||= ERB.new( IO.readlines( erb_filename( klass, view ) ).join ) ).result( _binding )
+	end
+  
+	def erb_filename( klass, view )
+		$stderr.puts "Looking for #{path_for( klass, view)}"
+		 until File.exists?( path_for( klass, view ) )
+		   klass = klass.superclass
+	    end
+	    path_for( klass, view )
+	end
+
+  	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
+	end
+	
+	def frame_erb
+		@frame_erb ||= load_frame_erb
+	end
+	
+	def load_frame_erb
+		if File.exists? "#{$SETTINGS[:root_directory]}/views/frame.rhtml"
+			ERB.new( IO.readlines( "#{$SETTINGS[:root_directory]}/views/frame.rhtml" ).join )
+		else
+			ERB.new( "<%= content_of_page %>" )
+		end
+	end
+	
+	def method_missing( method, *args, &block ) 
+		@wiki.send( method, *args, &block ) 
+  	end
+end