Pimki 1.0.092

data/app/models/chunks/wiki.rb

@@ -0,0 +1,82 @@
+require 'wiki_words'
+require 'chunks/chunk'
+require 'cgi'
+
+# Contains all the methods for finding and replacing wiki related
+# links.
+module WikiChunk
+  include Chunk
+
+  # A wiki link is the top-level class for anything that refers to
+  # another wiki page.
+  class WikiLink < Chunk::Abstract
+    # By default, no escaped text
+    def escaped_text() nil end
+
+    # Delimit the link text with markers to replace later unless
+    # the word is escaped. In that case, just return the link text
+    def mask(content) escaped_text || pre_mask + link_text + post_mask end
+
+    def regexp() Regexp.new(pre_mask + '(.*)?' + post_mask) end
+
+    def revert(content) content.sub!(regexp, text) end
+
+    # Do not keep this chunk if it is escaped.
+    # Otherwise, pass the link procedure a page_name and link_text and
+    # get back a string of HTML to replace the mask with.
+    def unmask(content)
+      return nil if escaped_text
+      return self if content.sub!(regexp) { |match| content.page_link(page_name, $1) }
+    end
+  end
+
+  # This chunk matches a WikiWord. WikiWords can be escaped
+  # by prepending a '\'. When this is the case, the +escaped_text+
+  # method will return the WikiWord instead of the usual +nil+.
+  # The +page_name+ method returns the matched WikiWord.
+  class Word < WikiLink
+    def self.pattern
+      Regexp.new('(\\\\)?(' + WikiWords::WIKI_WORD_PATTERN + ')\b', 0, "utf-8")
+    end
+
+    attr_reader :page_name
+
+    def initialize(match_data)
+      super(match_data)
+      @escape = match_data[1]
+      @page_name = match_data[2]
+    end
+
+    def escaped_text() (@escape.nil? ? nil : page_name) end
+    def link_text() WikiWords.separate(page_name) end	
+  end
+
+  # This chunk handles [[bracketted wiki words]] and 
+  # [[AliasedWords|aliased wiki words]]. The first part of an
+  # aliased wiki word must be a WikiWord. If the WikiWord
+  # is aliased, the +link_text+ field will contain the
+  # alias, otherwise +link_text+ will contain the entire
+  # contents within the double brackets.
+  #
+  # NOTE: This chunk must be tested before WikiWord since
+  #       a WikiWords can be a substring of a WikiLink. 
+  class Link < WikiLink
+    def self.pattern() /\[\[([^\]]+)\]\]/ end
+    ALIASED_LINK_PATTERN= Regexp.new('^(.*)?\|(.*)$', 0, "utf-8")
+
+    attr_reader :page_name, :link_text
+
+    def initialize(match_data)
+      super(match_data)
+
+	  # If the like is aliased, set the page name to the first bit
+	  # and the link text to the second, otherwise set both to the
+	  # contents of the double brackets.
+      if match_data[1] =~ ALIASED_LINK_PATTERN
+        @page_name, @link_text = $1, $2
+      else
+        @page_name, @link_text = match_data[1], match_data[1]
+      end
+    end
+  end
+end

data/app/models/chunks/wiki_test.rb

@@ -0,0 +1,36 @@
+require 'chunks/wiki'
+require 'chunks/match'
+require 'test/unit'
+
+class WikiTest < Test::Unit::TestCase
+  include ChunkMatch
+
+  def test_simple
+	match(WikiChunk::Word, 'This is a WikiWord okay?', :page_name => 'WikiWord')
+  end
+
+  def test_escaped
+	match(WikiChunk::Word, 'Do not link to an \EscapedWord',
+		:page_name => 'EscapedWord', :escaped_text => 'EscapedWord'
+	)
+  end
+
+  def test_simple_brackets
+	match(WikiChunk::Link, 'This is a [[bracketted link]]',
+		:page_name => 'bracketted link', :escaped_text => nil
+	)
+  end
+
+  def test_complex_brackets
+	match(WikiChunk::Link, 'This is a tricky link [[Sperberg-McQueen]]',
+		:page_name => 'Sperberg-McQueen', :escaped_text => nil
+	)
+  end
+
+# MDR: I'm not sure how to deal with this case just yet...
+#
+#  def test_textile_link
+#	assert_no_match(WikiChunk::Word.pattern, '"Here is a special link":SpecialLink')
+#  end
+
+end

data/app/models/page.rb

@@ -0,0 +1,91 @@
+require "date"
+require "page_lock"
+require "revision"
+require "wiki_words"
+require "chunks/wiki"
+
+class Page
+  include PageLock
+
+  CONTINOUS_REVISION_PERIOD = 30 * 60 # 30 minutes
+
+  attr_accessor :name, :last_visited, :viewed
+  attr_reader   :revisions, :web
+  
+  def initialize(web, name, content, created_at, author)
+    @web, @name, @revisions = web, name, []
+    revise(content, created_at, author)
+  end
+
+  def revise(content, created_at, author)
+    if !@revisions.empty? && continous_revision?(created_at, author)
+      @revisions.last.created_at = Time.now
+      @revisions.last.content    = content
+      @revisions.last.clear_display_cache
+    else
+      @revisions << Revision.new(self, @revisions.length, content, created_at, author)
+    end
+    
+    web.refresh_pages_with_references(name) if @revisions.length == 1
+  end
+  
+  def rollback(revision_number, created_at, author_ip = nil)
+    roll_back_revision = @revisions[revision_number].dup
+    revise(roll_back_revision.content, created_at, Author.new(roll_back_revision.author, author_ip))
+  end
+  
+  def revisions?
+    revisions.length > 1
+  end
+  
+  def revised_on
+    created_on
+  end
+  
+  def pretty_revised_on
+    DateTime.new(revised_on.year, revised_on.mon, revised_on.day).strftime "%B %e, %Y" 
+  end
+  
+  def in_category?(cat)
+    cat.nil? || cat.empty? || categories.include?(cat)
+  end
+
+  def categories
+    display_content.find_chunks(Category).map { |cat| cat.list }.flatten
+  end
+  
+  def authors
+    revisions.collect { |rev| rev.author }
+  end
+
+  def references
+    web.select.pages_that_reference(name)
+  end
+
+  # Returns the original wiki-word name as separate words, so "MyPage" becomes "My Page".
+  def plain_name
+    WikiWords.separate(name, web.brackets_only)
+  end
+
+  def link(options = {})
+    web.make_link(name, nil, options)
+  end
+  
+  def author_link(options = {})
+    web.make_link(author, nil, options)
+  end
+  
+  def last_visited()  @last_visited || revisions.last.created_at end
+  def viewed() @viewed ||= 0 end
+  
+  
+  private
+    def continous_revision?(created_at, author)
+      @revisions.last.author == author && @revisions.last.created_at + CONTINOUS_REVISION_PERIOD > created_at
+    end
+  
+    # Forward method calls to the current revision, so the page responds to all revision calls
+    def method_missing(method_symbol)
+      revisions.last.send(method_symbol)
+    end
+end

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,73 @@
+# 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 by_last_visited #{{{
+    self.sort_by { |page| [page.last_visited] }.reverse
+  end #}}}
+  
+  def by_most_viewed #{{{
+    self.sort_by { |page| [page.viewed] }.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/page_test.rb

@@ -0,0 +1,76 @@
+require "test/unit"
+require "web"
+require "page"
+
+class MockWeb < Web
+  def initialize() super('test','test') end
+  def [](wiki_word) %w( MyWay ThatWay SmartEngine ).include?(wiki_word) end
+  def refresh_pages_with_references(name) end
+end
+
+class PageTest < Test::Unit::TestCase
+  def setup
+    @page = Page.new(
+      MockWeb.new,
+      "FirstPage", 
+      "HisWay would be MyWay in kinda ThatWay in HisWay though MyWay \\OverThere -- see SmartEngine in that SmartEngineGUI", 
+      Time.local(2004, 4, 4, 16, 50),
+      "DavidHeinemeierHansson"
+    )
+  end
+
+  def test_basics
+    assert_equal "First Page", @page.plain_name
+    assert_equal "April  4, 2004", @page.pretty_revised_on
+  end
+
+  def test_locking
+    assert !@page.locked?(Time.local(2004, 4, 4, 16, 50))
+
+    @page.lock(Time.local(2004, 4, 4, 16, 30), "DavidHeinemeierHansson")
+
+    assert @page.locked?(Time.local(2004, 4, 4, 16, 50))
+    assert !@page.locked?(Time.local(2004, 4, 4, 17, 1))
+
+    @page.unlock
+
+    assert !@page.locked?(Time.local(2004, 4, 4, 16, 50))
+  end
+  
+  def test_locking_duration
+    @page.lock(Time.local(2004, 4, 4, 16, 30), "DavidHeinemeierHansson")
+
+    assert_equal 15, @page.lock_duration(Time.local(2004, 4, 4, 16, 45))
+  end
+  
+  def test_revision
+    @page.revise("HisWay would be MyWay in kinda lame", Time.local(2004, 4, 4, 16, 55), "MarianneSyhler")
+    assert_equal 2, @page.revisions.length, "Should have two revisions"
+    assert_equal "MarianneSyhler", @page.author, "Mary should be the author now"
+    assert_equal "DavidHeinemeierHansson", @page.revisions.first.author, "David was the first author"
+  end
+  
+  def test_rollback
+    @page.revise("spot two", Time.now, "David")
+    @page.revise("spot three", Time.now + 2000, "David")
+    assert_equal 3, @page.revisions.length, "Should have three revisions"
+    @page.rollback(1, Time.now)
+    assert_equal "spot two", @page.content
+  end
+  
+  def test_continous_revision
+    @page.revise("HisWay would be MyWay in kinda lame", Time.local(2004, 4, 4, 16, 55), "MarianneSyhler")
+    assert_equal 2, @page.revisions.length
+
+    @page.revise("HisWay would be MyWay in kinda update", Time.local(2004, 4, 4, 16, 57), "MarianneSyhler")
+    assert_equal 2, @page.revisions.length
+    assert_equal "HisWay would be MyWay in kinda update", @page.revisions.last.content
+
+    @page.revise("HisWay would be MyWay in the house", Time.local(2004, 4, 4, 16, 58), "DavidHeinemeierHansson")
+    assert_equal 3, @page.revisions.length
+    assert_equal "HisWay would be MyWay in the house", @page.revisions.last.content
+
+    @page.revise("HisWay would be MyWay in my way", Time.local(2004, 4, 4, 17, 30), "DavidHeinemeierHansson")
+    assert_equal 4, @page.revisions.length
+  end
+end

data/app/models/revision.rb

@@ -0,0 +1,91 @@
+
+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)
+      #$stderr << "Rendering: #{page.name}\n"
+      @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