instiki 0.9.2

data/app/models/page_lock.rb

@@ -0,0 +1,24 @@
+# Contains all the lock methods to be mixed in with the page
+module PageLock
+  LOCKING_PERIOD = 30 * 60 # 30 minutes
+
+  def lock(time, locked_by)
+    @locked_at, @locked_by = time, locked_by
+  end
+  
+  def lock_duration(time)
+    ((time - @locked_at) / 60).to_i unless @locked_at.nil?
+  end
+  
+  def unlock
+    @locked_at = nil
+  end
+  
+  def locked?(comparison_time)
+    @locked_at + LOCKING_PERIOD > comparison_time unless @locked_at.nil?
+  end
+
+  def locked_by_link
+    web.make_link(@locked_by)
+  end
+end

data/app/models/page_set.rb

@@ -0,0 +1,64 @@
+# Container for a set of pages with methods for manipulation.
+class PageSet < Array
+  attr_reader :web
+
+  def initialize(web, pages, accept_proc)
+    @web = web
+    if accept_proc.nil? then 
+      super(pages)
+    else
+      super(pages.select { |page| accept_proc[page] })
+    end
+  end
+
+  def most_recent_revision
+    self.sort_by { |page| [page.created_at] }.reverse.first.created_at
+  end
+
+  def by_name
+    self.sort_by { |page| [page.name] } 
+  end
+
+  def by_revision
+    self.sort_by { |page| [page.created_at] }.reverse 
+  end
+
+  def pages_that_reference(page_name)
+    self.select { |page| page.wiki_words.include?(page_name) }
+  end
+
+  def pages_authored_by(author)
+    self.select { |page| page.authors.include?(author) }
+  end
+
+  def characters
+    self.inject(0) { |chars,page| chars += page.content.size }
+  end
+
+  # Returns all the orphaned pages in this page set. That is,
+  # pages in this set for which there is no reference in the web.
+  # The HomePage and author pages are always assumed to have
+  # references and so cannot be orphans
+  def orphaned_pages
+    references = web.select.wiki_words + ["HomePage"] + web.select.authors
+    self.reject { |page| references.include?(page.name) } 
+  end
+
+  # Returns all the wiki words in this page set for which
+  # there are no pages in this page set's web
+  def wanted_pages
+    wiki_words - web.select.names
+  end
+
+  def names
+    self.map { |page| page.name }
+  end
+
+  def wiki_words
+    self.inject([]) { |wiki_words, page| wiki_words << page.wiki_words }.flatten.uniq
+  end
+
+  def authors
+    self.inject([]) { |authors, page| authors << page.authors }.flatten.uniq.sort
+  end
+end

data/app/models/revision.rb

@@ -0,0 +1,90 @@
+$: << File.dirname(__FILE__) + "../../libraries"
+
+require "diff/diff"
+
+require "wiki_content"
+require "chunks/wiki"
+
+require "date"
+require "author"
+require "page"
+
+class Revision
+  attr_accessor :page, :number, :content, :created_at, :author
+
+  def initialize(page, number, content, created_at, author)
+    @page, @number, @created_at, @author = page, number, created_at, author
+    self.content = content
+  end
+
+  # Ensure that the wiki content is parsed when ever it is updated.
+  def content=(content)
+    @content = content
+  end
+
+  def created_on
+    Date.new(@created_at.year, @created_at.mon, @created_at.day)
+  end
+
+  def pretty_created_at
+    # Must use DateTime because Time doesn't support %e on at least some platforms
+    DateTime.new(
+      @created_at.year, @created_at.mon, @created_at.day, @created_at.hour, @created_at.min
+    ).strftime "%B %e, %Y %H:%M" 
+  end
+
+  def next_revision
+    page.revisions[number + 1]
+  end
+
+  def previous_revision
+    number - 1 >= 0 && page.revisions[number - 1]
+  end
+
+  # Returns an array of all the WikiWords present in the content of this revision.
+  def wiki_words
+    unless @wiki_words_cache 
+      wiki_chunks = display_content.find_chunks(WikiChunk::WikiLink)
+      @wiki_words_cache = wiki_chunks.map { |c| ( c.escaped_text ? nil : c.page_name ) }.compact.uniq
+    end
+    @wiki_words_cache
+  end  
+
+  # Returns an array of all the WikiWords present in the content of this revision.
+  # that already exists as a page in the web.
+  def existing_pages
+    wiki_words.select { |wiki_word| page.web.pages[wiki_word] }
+  end
+
+  # Returns an array of all the WikiWords present in the content of this revision
+  # that *doesn't* already exists as a page in the web.
+  def unexisting_pages
+    wiki_words - existing_pages
+  end  
+
+	# Explicit check for new type of display cache with find_chunks method.
+	# Ensures new version works with older snapshots.
+  def display_content
+    unless @display_cache && @display_cache.respond_to?(:find_chunks)
+      @display_cache = WikiContent.new(self)
+    end
+    @display_cache
+  end
+
+  def display_diff
+    previous_revision ? HTMLDiff.diff(previous_revision.display_content, display_content) : display_content
+  end
+
+  def clear_display_cache
+    @display_cache = @published_cache = @wiki_words_cache = nil
+  end
+  
+  def display_published
+    @published_cache = WikiContent.new(self, {:mode => :publish}) if @published_cache.nil?
+    @published_cache
+  end
+
+  def display_content_for_export
+    WikiContent.new(self, {:mode => :export} )
+  end  
+end

data/app/models/web.rb

@@ -0,0 +1,89 @@
+require "cgi"
+require "page"
+require "page_set"
+require "wiki_words"
+require "zip/zip"
+
+class Web
+  attr_accessor :pages, :name, :address, :password
+  attr_accessor :markup, :color, :safe_mode, :additional_style, :published, :brackets_only, :count_pages
+  
+  def initialize(name, address, password = nil)
+    @name, @address, @password, @safe_mode = name, address, password, false
+    @pages = {}
+  end
+
+  def add_page(page)
+    @pages[page.name] = page
+  end
+
+  def remove_pages(pages_to_be_removed)
+    pages.delete_if { |page_name, page| pages_to_be_removed.include?(page) }
+  end
+  
+  def select(&accept)
+    PageSet.new(self, @pages.values, accept)
+  end
+  
+  def revised_on
+    select.most_recent_revision
+  end
+    
+  def authors 
+    select.authors 
+  end
+
+  def categories
+    select.map { |page| page.categories }.flatten.uniq.sort
+  end
+
+  # Create a link for the given page name and link text based
+  # on the render mode in options and whether the page exists
+  # in the this web.
+  def make_link(name, text = nil, options = {})
+    page = pages[name]
+    text = text || WikiWords.separate(name)
+    link = CGI.escape(name)
+    
+    case options[:mode]
+      when :export
+        if page then "<a class=\"existingWikiWord\" href=\"#{link}.html\">#{text}</a>"
+        else "<span class=\"newWikiWord\">#{text}</span>" end
+      when :publish
+        if page then "<a class=\"existingWikiWord\" href=\"../show/#{link}\">#{text}</a>"
+        else "<span class=\"newWikiWord\">#{text}</span>" end
+      else
+        if page then "<a class=\"existingWikiWord\" href=\"../show/#{link}\">#{text}</a>"
+        else "<span class=\"newWikiWord\">#{text}<a href=\"../show/#{link}\">?</a></span>" end
+    end
+  end
+
+
+  # Clears the display cache for all the pages with references to 
+  def refresh_pages_with_references(page_name)
+    select.pages_that_reference(page_name).each { |page| 
+      page.revisions.each { |revision| revision.clear_display_cache }
+    }
+  end
+  
+  def refresh_revisions
+    select.each { |page| page.revisions.each { |revision| revision.clear_display_cache } }
+  end
+  
+  # Default values
+  def markup()        @markup || :textile end
+  def color()         @color  || "008B26" end
+  def brackets_only() @brackets_only || false end
+  def count_pages()   @count_pages || false end
+
+  private
+    # Returns an array of all the wiki words in any current revision
+    def wiki_words
+      pages.values.inject([]) { |wiki_words, page| wiki_words << page.wiki_words }.flatten.uniq
+    end
+    
+    # Returns an array of all the page names on this web
+    def page_names
+      pages.keys
+    end
+end

data/app/models/wiki_content.rb

@@ -0,0 +1,105 @@
+require 'cgi'
+require 'chunks/engines'
+require 'chunks/category'
+require 'chunks/include'
+require 'chunks/wiki'
+require 'chunks/literal'
+require 'chunks/uri'
+require 'chunks/nowiki'
+
+# Wiki content is just a string that can process itself with a chain of
+# actions. The actions can modify wiki content so that certain parts of
+# it are protected from being rendered by later actions.
+#
+# When wiki content is rendered, it can be interrogated to find out 
+# which chunks were rendered. This means things like categories, wiki 
+# links, can be determined.
+#
+# Exactly how wiki content is rendered is determined by a number of 
+# settings that are optionally passed in to a constructor. The current
+# options are:
+#  * :engine 
+#    => The structural markup engine to use (Textile, Markdown, RDoc)
+#  * :engine_opts
+#    => A list of options to pass to the markup engines (safe modes, etc)
+#  * :pre_engine_actions
+#    => A list of render actions or chunks to be processed before the
+#       markup engine is applied. By default this is:    
+#       Category, Include, URIChunk, WikiChunk::Link, WikiChunk::Word        
+#  * :post_engine_actions
+#    => A list of render actions or chunks to apply after the markup 
+#       engine. By default these are:    
+#       Literal::Pre, Literal::Tags
+#  * :mode
+#    => How should the content be rendered? For normal display (:display), 
+#       publishing (:publish) or export (:export)?
+#
+# AUTHOR: Mark Reid <mark @ threewordslong . com>
+# CREATED: 15th May 2004
+# UPDATED: 22nd May 2004
+class WikiContent < String
+
+  PRE_ENGINE_ACTIONS  = [ NoWiki, Category, Include, URIChunk, WikiChunk::Link, WikiChunk::Word ] 
+  POST_ENGINE_ACTIONS = [ Literal::Pre, Literal::Tags ]
+  DEFAULT_OPTS = {
+    :pre_engine_actions  => PRE_ENGINE_ACTIONS,
+    :post_engine_actions => POST_ENGINE_ACTIONS,
+    :engine              => Engines::Textile,
+    :engine_opts         => [],
+    :mode                => [:display]
+  }
+
+  attr_reader :web, :options, :rendered
+
+  # Create a new wiki content string from the given one.
+  # The options are explained at the top of this file.
+  def initialize(revision, options = {})
+    @revision = revision
+    @web = @revision.page.web
+
+    # Deep copy of DEFAULT_OPTS to ensure that changes to PRE/POST_ENGINE_ACTIONS stay local
+    @options = Marshal.load(Marshal.dump(DEFAULT_OPTS)).update(options)
+    @options[:engine] = Engines::MAP[@web.markup] || Engines::Textile
+    @options[:engine_opts] = (@web.safe_mode ? [:filter_html, :filter_styles] : [])
+
+    @options[:pre_engine_actions].delete(WikiChunk::Word) if @web.brackets_only
+
+    super(@revision.content)
+
+    begin
+      render!(@options[:pre_engine_actions] + [@options[:engine]] + @options[:post_engine_actions])
+    rescue => e
+      @rendered = e.message
+    end
+  end
+
+  # Call @web.page_link using current options.
+  def page_link(name, text) 
+    @web.make_link(name, text, @options) 
+  end
+
+  # Find all the chunks of the given types
+  def find_chunks(chunk_type)
+    rendered.select { |chunk| chunk.kind_of?(chunk_type) }
+  end
+
+  # Render this content using the specified actions.
+  def render!(chunk_types)
+    @chunks = []
+    chunk_types.each { |chunk_type| self.apply_type!(chunk_type) }
+    
+    @rendered = @chunks.map { |chunk| chunk.unmask(self) }.compact
+    (@chunks - @rendered).each { |chunk| chunk.revert(self) }
+  end
+  
+  # Find all the chunks of the given type in this content
+  # Each time the type's pattern is matched, create a new
+  # chunk for it, and replace the occurance of the chunk
+  # in this content with its mask.
+  def apply_type!(chunk_type)
+    self.gsub!( chunk_type.pattern ) do |match|	
+      @chunks << chunk_type.new($~)
+      @chunks.last.mask(self)
+    end
+  end
+end

data/app/models/wiki_service.rb

@@ -0,0 +1,83 @@
+$:.unshift(File.dirname(__FILE__) + "/../../libraries/")
+
+require "madeleine_service"
+require "web"
+require "page"
+require "author"
+
+class WikiService < MadeleineService
+  attr_reader :webs, :system
+
+  def initialize
+    @webs, @system = {}, {}
+  end
+
+  def setup?
+    !@system.empty?
+  end
+
+  def authenticate(password)
+    password == (@system["password"] || "instiki")
+  end
+
+  def setup(password, web_name, web_address)
+    @system["password"] = password
+    create_web(web_name, web_address)
+  end
+
+  def create_web(name, address, password = nil)
+    @webs[address] = Web.new(name, address, password) unless @webs[address]
+  end
+  
+  def update_web(old_address, new_address, name, markup, color, additional_style, safe_mode = false, 
+      password = nil, published = false, brackets_only = false, count_pages = false)
+    if old_address != new_address
+      @webs[new_address] = @webs[old_address]
+      @webs.delete(old_address)
+      @webs[new_address].address = new_address
+    end
+    
+    web = @webs[new_address]
+    web.refresh_revisions if settings_changed?(web, markup, safe_mode, brackets_only)
+    
+    web.name, web.markup, web.color, web.additional_style, web.safe_mode = 
+      name, markup, color, additional_style, safe_mode
+      
+    web.password, web.published, web.brackets_only, web.count_pages =
+      password, published, brackets_only, count_pages
+  end
+
+  def read_page(web_address, page_name)
+    web = @webs[web_address]
+    web ? web.pages[page_name] : nil
+  end
+
+  def write_page(web_address, page_name, content, written_on, author)
+    page = Page.new(@webs[web_address], page_name, content, written_on, author)
+    @webs[web_address].add_page(page)
+    page
+  end
+  
+  def revise_page(web_address, page_name, content, revised_on, author)
+    page = read_page(web_address, page_name)
+    page.revise(content, revised_on, author)
+    page
+  end
+
+  def rollback_page(web_address, page_name, revision_number, created_at, author_id = nil)
+    page = read_page(web_address, page_name)
+    page.rollback(revision_number, created_at, author_id)
+    page
+  end
+  
+  def remove_orphaned_pages(web_address)
+    @webs[web_address].remove_pages(@webs[web_address].select.orphaned_pages)
+  end
+  
+  private
+    def settings_changed?(web, markup, safe_mode, brackets_only)
+      web.markup != markup || 
+      web.safe_mode != safe_mode || 
+      web.brackets_only != brackets_only
+    end
+end