Soks 0.0.2

data/contrib/redcloth_license.txt

@@ -0,0 +1,27 @@
+Redcloth License
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, 
+  this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name Textile nor the names of its contributors may be used to
+  endorse or promote products derived from this software without specific
+  prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/lib/authenticators.rb

@@ -0,0 +1,79 @@
+require 'webrick/config'
+require 'webrick/httpstatus'
+require 'webrick/httpauth/authenticator'
+require 'base64'
+
+module WEBrick
+  module HTTPAuth
+		class NotAuthentication
+			
+			include WEBrick::HTTPAuth::Authenticator
+			
+			AuthScheme = "Basic"
+	
+			def  initialize( realm = "editing" )
+				config = { :UserDB => "nodb" , :Realm => realm }
+		      check_init(config)
+				@config = Config::BasicAuth.dup.update(config)
+		   end
+
+		   def authenticate(req, res)
+		     unless basic_credentials = check_scheme(req)
+		       challenge(req, res)
+		     end
+		     userid, password = decode64(basic_credentials).split(":", 2) 
+		     if userid.empty?
+		       error("user id was not given.")
+		       challenge(req, res)
+		     end
+		     info("%s: authentication succeeded.", userid)
+		     req.user = userid
+		   end
+
+		   def challenge(req, res)
+		     res[@response_field] = "#{@auth_scheme} realm=\"#{@realm}\""
+		     raise @auth_exception
+		   end
+		end
+		
+    class OnePasswordAuthentication
+      include Authenticator
+
+      AuthScheme = "Basic"
+
+      attr_reader :realm, :userdb, :logger
+
+      def initialize( password = "", realm = "editing" )
+  			config = { :UserDB => "nodb" , :Realm => realm }
+		   check_init(config)
+			@config = Config::BasicAuth.dup.update(config)
+			@password = password
+      end
+
+      def authenticate(req, res)
+        unless basic_credentials = check_scheme(req)
+          challenge(req, res)
+        end
+        userid, password = decode64(basic_credentials).split(":", 2) 
+        password ||= ""
+        if userid.empty?
+          error("user id was not given.")
+          challenge(req, res)
+        end
+ 
+        if password != @password
+          error("%s: password unmatch.", userid)
+          challenge(req, res)
+        end
+        info("%s: authentication succeeded.", userid)
+        req.user = userid
+      end
+
+      def challenge(req, res)
+        res[@response_field] = "#{@auth_scheme} realm=\"#{@realm}\""
+        raise @auth_exception
+      end
+    end
+
+	end
+end

data/lib/soks-helpers.rb

@@ -0,0 +1,321 @@
+require 'soks'
+require 'net/smtp'
+
+class AutomaticUpdateCrossLinks
+
+	def initialize( wiki )
+		@wiki = wiki
+		@wiki.watch_for( :page_created ) { |event, page| new_page( page ) }
+		@wiki.watch_for( :page_deleted ) { |event, page| delete_page( page ) }
+		@wiki.watch_for( :page_revised ) { |event, page| page_revised( page ) }
+		update_all_pages
+	end
+
+	def new_page( page )
+		@wiki.rollingmatch[ page.name ] = page
+		titleregex = Regexp.new( page.name, Regexp::IGNORECASE )
+		@wiki.each { |name, linkedpage | 
+			unless name[0,10] == 'Site Index'
+				@wiki.refresh_redcloth( linkedpage ) if linkedpage.textile =~ titleregex
+			end
+		}
+	end
+	
+	def delete_page( page )
+		@wiki.rollingmatch.delete( page.name )
+		page.links_to.each { |linkedpage| @wiki.refresh_redcloth( linkedpage ) }
+	end
+	
+	def page_revised( page )
+		page.inserted_into.each { |including_page| 
+			@wiki.refresh_redcloth( including_page ) 
+		}
+	end
+	
+	def update_all_pages
+		@wiki.each { |pagename, page| @wiki.rollingmatch[ page.name ] = page }
+		@wiki.each { |pagename, page| @wiki.refresh_redcloth( page ) }
+	end
+end
+
+class AutomaticRecentChanges
+
+	IGNORED_AUTHORS = /^Automatic/
+	
+	def initialize( wiki, lines = 200, pagename = "Recent Changes to This Site", author = "AutomaticRecentChanges" )
+		@wiki, @lines, @pagename, @author = wiki, lines, pagename, author
+		@wiki.watch_for( :page_revised ) { |event, page, revision| revised( page, revision ) }
+	end
+	
+	def revised( page, revision )
+		unless ( revision.author =~ IGNORED_AUTHORS )
+			add_recent_change( page, revision )
+		end
+	end
+		
+	def add_recent_change( page, revision )
+		changes_content = "On #{revision.created_at.strftime('%Y %b %d')}, #{revision.author} made these changes to [[#{page}]]:\n"
+		revision.changes.each do |change_group| change_group.each do |change|
+				next if change[2] == ""
+				changes_content <<  case change[0]
+				# Note, +/- reversed because diffs stored as diff from CURRENT version
+				when "-" ; "| #{change[1]} | -<notextile>#{change[2]}</notextile>- |\n"
+				when "+" ; "| #{change[1]} | <notextile>#{change[2]}</notextile> |\n"
+				end
+		end  end
+		changes_content << "\n"
+		changes_content << @wiki.page( @pagename ).content.first_lines( @lines ) unless @wiki.page( @pagename ).empty?
+		@wiki.revise( @pagename , changes_content, @author)
+	end	
+end
+
+class AutomaticOnePageIndex
+	
+	def initialize( wiki, pagename = "Site Index", author = "AutomaticIndex"  )
+		@wiki, @pagename, @author = wiki, pagename, author
+		@wiki.watch_for( :page_created, :page_deleted ) { update_index }
+		update_index
+	end	
+	
+	def update_index
+		index = @wiki.sort_by{ |name, page| page.name_for_index.capitalize }.map{ |name, page| "* [[ #{page} ]]\n" }
+		@wiki.revise( @pagename, "h1. Index\n\n#{index}", @author )
+	end
+end
+
+class AutomaticMultiPageIndex < AutomaticOnePageIndex
+	
+	def update_index
+		buckets = separate_pages_by_first_character
+		link_bar = link_bar_from_buckets( buckets )
+		buckets.each do |firstcharacter, pages|
+			index = pages.sort_by{ |page| page.name_for_index.capitalize }.map{ |page| "* [[ #{page} ]]\n" }
+			@wiki.revise( "#{@pagename} #{firstcharacter}", "h1. Site Index #{firstcharacter}\n\n#{link_bar}\n\n#{index}", @author )
+		end
+		@wiki.revise( @pagename, "h1. Site Index\n\n#{link_bar}", @author )
+	end
+	
+	def separate_pages_by_first_character
+		buckets = Hash.new
+		@wiki.each do |name, page|
+			( buckets[ page.name_for_index[0,1].upcase ] ||= [] ) << page
+		end
+		buckets
+	end
+	
+	def link_bar_from_buckets( buckets )
+		buckets.keys.sort.map { |letter| "[[ #{letter} : #{@pagename} #{letter} ]]\n" }.join(' ')
+	end
+end
+
+class FiniteUniqueList
+	include Enumerable
+	
+	attr_accessor :max_size
+	
+	def initialize( max_size = nil )
+		@max_size = max_size
+		@list = Array.new
+	end
+
+	def add( item )
+		remove( item )
+		@list << item
+		remove_excess_items
+	end
+	
+	def remove( item )
+		@list.delete( item )
+	end
+	
+	def each
+		@list.reverse_each { |item| yield item }
+	end
+	
+	def empty?; @list.empty? end
+	
+	private 
+	
+	def remove_excess_items
+		if @max_size
+			while @list.size > @max_size
+				@list.shift
+			end
+		end
+	end
+end
+
+class AutomaticSummary
+	
+	DEFAULT_SETTINGS = {
+		:regexp_for_pages => /.*/,
+		:max_pages_to_show => nil,
+		:pagename => 'Summary',
+		:author => 'AutomaticSummary',
+		:lines_to_include => nil,
+		:only_new_pages => false,
+	}
+
+	attr_reader :settings, :pages_in_summary
+
+	def initialize( wiki, settings = {} )
+		@wiki = wiki
+		@settings = DEFAULT_SETTINGS.merge( settings )
+		@pages_in_summary = FiniteUniqueList.new( @settings[:max_pages_to_show] )
+		scan_for_pages_to_summarise
+		render_summary
+		@wiki.watch_for( @settings[:only_new_pages] ? :page_created : :page_revised ) { |event, page| check_whether_to_add_page( page ) }
+		@wiki.watch_for( :page_deleted ) { |event, page| check_whether_to_remove_page( page ) }
+	end
+	
+	def check_whether_to_add_page( page )
+		return if page.name == @settings[:pagename]
+		if page.name=~ @settings[:regexp_for_pages]
+			@pages_in_summary.add( page ) 
+			render_summary
+		end
+	end
+	
+	def check_whether_to_remove_page( page )
+		render_summary if @pages_in_summary.remove( page )	
+	end
+	
+	def scan_for_pages_to_summarise
+		@wiki.select do |name,page| 
+			name=~ @settings[:regexp_for_pages]
+		end.sort_by  do |name, page| 
+			(@settings[:only_new_pages] ? page.revision[0] : page).created_at
+		end.each 	 do |name, page|
+			@pages_in_summary.add page
+		end
+	end
+	
+	def render_summary
+		if @pages_in_summary.empty?
+			@wiki.revise( @settings[:pagename], "No pages found to summarise" , @settings[:author] )
+		else
+			content = ""
+			@pages_in_summary.each do |page|
+				content << "<div class='subpage'>\n\n"
+				content << render_page( page )
+				content << "\n\np(more). [[(more) : #{page.name}]]\n\n"
+				content << "</div>\n"
+			end
+			@wiki.revise( @settings[:pagename], content , @settings[:author] )
+		end
+	end
+	
+	def render_page( page )
+		if @settings[:lines_to_include] 
+			page.textile.first_lines( @settings[:lines_to_include] ) 
+		else
+			page.textile
+		end
+	end
+end 
+
+class AutomaticCalendar
+	
+	attr_reader :month_pagename, :day_pagename
+	
+	def initialize( wiki, month_pagename = '%Y %b', day_pagename = '%Y %b %d', author = "AutomaticCalendar" )
+		@wiki, @month_pagename, @day_pagename, @author = wiki, month_pagename, day_pagename, author
+		Thread.new do
+			loop do
+				Time.now.month.upto( Time.now.month+12 ) { |m| render_month( m ) }
+				sleep(60*60*24)
+			end 
+		end
+	end
+	
+	def render_month( month )
+		@wiki.revise( month_pagename( month  ), calendar_for( month ) , @author ) unless @wiki.exists?( month_pagename( month ) )
+	end
+	
+	def calendar_for( month )
+		content = "<div class='calendar'>\n"
+		content << "|_. Su |_. Mo |_. Tu |_. We |_. Th |_. Fr |_. Sa |\n"
+		1.upto( time_for( month, 1 ).wday ) { content << "| . " }
+		day = nil
+		1.upto( 31 ) do |day_no|
+			day = time_for( month, day_no )
+			break if day.month > month
+			content << "| [[ #{day_no} : #{day_pagename( day )} ]] "
+			content << "|\n" if day.wday == 6
+		end
+		day.wday.upto( 5 ) { content << "| . " }
+		content << "|\n"
+		content << "\n\n< #{month_pagename( month-1 )}  #{month_pagename( month+1 )} >\n"		
+	end
+	
+	def time_for( month, day = 1 )
+		year = Time.now.year
+		if month > 12
+			year +=1
+			month -= 12
+		elsif month < 1
+			year -= 1
+			month = month + 12
+		end
+		if day > 31
+			month += 1
+			day -= 31
+		end
+		Time.local( year, month, day, 8, 0 )
+	end
+	
+	def month_pagename( month = Time.now.month ) time_for( month ).strftime(@month_pagename) end
+	
+	def day_pagename( date = Time.now ) date.strftime(@day_pagename) end
+end
+
+class AutomaticUpcomingEvents
+	
+	def initialize( wiki, calendar, days_passed = 0, days_future = 7, pagename = 'Upcoming Events', author = "AutomaticUpcomingEvents" )
+		@wiki, @calendar, @days_passed, @days__future, @pagename, @author = wiki, calendar, days_passed, days_future, pagename, author
+		@wiki.watch_for( :page_revised ) { |event, page| page_revised( page ) }
+		Thread.new do
+			loop do
+				render_upcoming_events
+				sleep(60*60)
+			end 
+		end
+	end
+
+	def page_revised( page )
+		render_upcoming_events if page.name =~ /^\d\d\d\d ... \d\d/
+	end
+	
+	def render_upcoming_events
+		content = "<div class='upcomingevents'>\n"
+		Time.now.day.upto( Time.now.day+7 ) do |day|
+			time =  @calendar.time_for( Time.now.month, day )
+			content << "| [[ #{relative_day( time ) } : #{@calendar.day_pagename( time )} ]] |"
+			content << (@wiki.exists?( @calendar.day_pagename(time) ) ? render_event( @calendar.day_pagename( time ) ) : "&nbsp; |\n")	
+		end
+		content << "\n\np(more). [[(more) : #{@calendar.month_pagename}]]\n\n"
+		content << "</div>\n"
+		@wiki.revise( "Upcoming Events", content , "AutomaticCalendar" ) 
+	end
+	
+	def relative_day( date )
+		case ( (date - @calendar.time_for( Time.now.month, Time.now.day ) ) / ( 60 * 60 * 24 ) ) # Days difference
+		when -7..-2	; 	date.strftime('Last %A')
+		when -1 		; 	"Yesterday"
+		when 0 		; 	"Today"
+		when 1 		; 	"Tomorrow"
+		when 2..7	;	date.strftime('%A')
+		else			; 	date.strftime('%A %d')
+		end
+	end
+	
+	def render_event( name )
+		page = @wiki.page( name )
+		headings = page.textile.select { |line| line =~ /^h\d\./ }
+		headings = headings.map { |heading| heading.to_s[4..-1].strip }
+		headings = [ page.textile[/.*?\n/] ] if headings.empty?
+		content = "[[ #{headings.shift} : #{page.name} ]] |\n"
+		headings.each { |heading| content << "| &nbsp; | [[ #{heading} : #{page.name} ]] |\n" }
+		content
+	end
+end

data/lib/soks-model.rb

@@ -0,0 +1,208 @@
+# Revision stores changes as a diff against the more recent content version
+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
+	
+	# 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
+	end
+	
+	def previous_content( page )
+		content( page ).split("\n").unpatch!(@changes).join("\n")
+	end
+end
+
+class Page
+	attr_reader :name, :content, :revisions
+	attr_accessor :links_from, :links_to, :inserted_into
+
+	# Returns an empty version of itself.
+  	def self.empty( name )
+	    empty = self.new( name, "Type what you want here and click save", "NoOne" )
+	    class << empty
+	      def textile; "[[Create #{name} (#{self.class}) : /edit/#{name} ]]" end
+			def empty?; true; end
+	    end
+	    empty
+    end
+
+	def initialize( name, content, author  )
+		@name, @content, @revisions = name, "", []
+		@links_from, @links_to = [], [] 
+		@inserted_into, @watchers = [], []
+		revise content, author
+	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
+		end
+	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
+	end	
+	
+	def revision( number ) 	@revisions[ number ] end
+
+	def deleted?
+		( content.strip.downcase == 'page deleted' ) || 
+		( content =~ /^content moved to /i )
+	end
+	
+	def empty?; @revisions.empty? end
+	
+	def score; @links_from.size + @links_to.size + @watchers.size end
+	
+	def <=>( otherpage ) 	self.score <=> otherpage.score 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
+end
+
+#Serves as a marker, so ImagePage and AttachmentPage can re-use the same view templates
+class UploadPage < Page
+end
+
+class ImagePage < UploadPage
+  def textile()
+  	deleted? ? content : "!#{content}(#{@name})!:/#{@name.url_encode}\n" 	
+  end
+  
+  def name_for_index; 	@name[ 10..-1].strip	end
+end
+
+class AttachmentPage < UploadPage 
+  def textile()
+  	deleted? ? content :  %Q{"#{@name}":#{content}\n} 	
+  end
+  def name_for_index; 	@name[ 9..-1].strip			end
+end
+
+class Wiki
+	include Enumerable
+  
+	def initialize( folder )
+		@folder = folder
+		@pages = Hash.new
+	    @page_classes = [ 
+	      [ /^picture of/i, ImagePage ],
+	      [ /^attached/i, AttachmentPage ],
+	      [ /.*/, Page ]
+	    ]
+	    load_all_pages_in( folder )
+	end
+	
+	def page( name )
+	 	@pages[ name.downcase ] || class_for( name ).empty( name )
+	end
+	
+	def each
+		@pages.each { |name, page| yield [name, page] unless page.deleted? }
+	end
+	
+	def exists?( name )
+	    @pages.include?( name.downcase ) && !page( name.downcase ).deleted?
+	end
+  
+	def revise( pagename, content, author )
+		mutate( pagename, content, author ) { |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"
+	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
+		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 
+		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 ) }
+	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
+	end
+end