instiki 0.9.2 → 0.10.0

data/app/models/file_yard.rb

@@ -0,0 +1,58 @@
+require 'fileutils'
+require 'instiki_errors'
+
+class FileYard
+
+  attr_reader :files_path
+
+  def initialize(files_path, max_upload_size)
+    @files_path = files_path
+    @max_upload_size = max_upload_size
+    FileUtils.mkdir_p(files_path) unless File.exist?(files_path)
+    @files = Dir["#{files_path}/*"].collect{|path| File.basename(path) if File.file?(path) }.compact
+  end
+
+  def upload_file(name, io)
+    sanitize_file_name(name)
+    if io.kind_of?(Tempfile)
+      io.close
+      check_upload_size(io.size)
+      FileUtils.mv(io.path, file_path(name))
+    else
+      content = io.read
+      check_upload_size(content.length)
+      File.open(file_path(name), 'wb') { |f| f.write(content) }
+    end
+    # just in case, restrict read access and prohibit write access to the uploaded file
+    FileUtils.chmod(0440, file_path(name))
+  end
+
+  def files
+    Dir["#{files_path}/*"].collect{|path| File.basename(path) if File.file?(path)}.compact
+  end
+
+  def has_file?(name)
+    files.include?(name)
+  end
+
+  def file_path(name)
+    "#{files_path}/#{name}"
+  end
+
+  SANE_FILE_NAME = /[-_\.A-Za-z0-9]{1,255}/
+
+  def sanitize_file_name(name)
+    unless name =~ SANE_FILE_NAME
+      raise Instiki::ValidationError.new("Invalid file name: '#{name}'.\n" +
+            "Only latin characters, digits, dots, underscores and dashes are accepted.")
+    end
+  end
+  
+  def check_upload_size(actual_upload_size)
+    if actual_upload_size > @max_upload_size.kilobytes
+      raise Instiki::ValidationError.new("Uploaded file size (#{actual_upload_size / 1024} " + 
+              "kbytes) exceeds the maximum (#{@max_upload_size} kbytes) set for this wiki")
+    end
+  end
+
+end

data/app/models/page.rb

@@ -1,86 +1,112 @@
-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_reader :name, :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
-  
-  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
+require 'date'
+require 'page_lock'
+require 'revision'
+require 'wiki_words'
+require 'chunks/wiki'
+
+class Page
+  include PageLock
+
+  attr_reader :name, :web
+  attr_accessor :revisions
+  
+  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 not @revisions.empty? and content == @revisions.last.content
+      raise Instiki::ValidationError.new(
+          "You have tried to save page '#{name}' without changing its content")
+    end
+
+    # A user may change a page, look at it and make some more changes - several times.
+    # Not to record every such iteration as a new revision, if the previous revision was done 
+    # by the same author, not more than 30 minutes ago, then update the last revision instead of
+    # creating a new one
+    if !@revisions.empty? && continous_revision?(created_at, author)
+      @revisions.last.created_at = created_at
+      @revisions.last.content = content
+      @revisions.last.clear_display_cache
+    else
+      @revisions << Revision.new(self, @revisions.length, content, created_at, author)
+    end
+
+    self.revisions.last.force_rendering
+    # at this point the page may not be inserted in the web yet, and therefore 
+    # references to the page itself are rendered as "unresolved". Clearing the cache allows 
+    # the page to re-render itself once again, hopefully _after_ it is inserted in the web
+    self.revisions.last.clear_display_cache
+    
+    @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 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
+
+  def linked_from
+    @web.select.pages_that_link_to(name)
+  end
+
+  def included_from
+    @web.select.pages_that_include(name)
+  end
+
+  # Returns the original wiki-word name as separate words, so "MyPage" becomes "My Page".
+  def plain_name
+    @web.brackets_only ? name : WikiWords.separate(name)
+  end
+
+  # used to build chunk ids. 
+  def id
+    @id ||= name.unpack('H*').first
+  end
+
+  def link(options = {})
+    @web.make_link(name, nil, options)
+  end
+
+  def author_link(options = {})
+    @web.make_link(author, nil, options)
+  end
+
+  private
+
+  def continous_revision?(created_at, author)
+    @revisions.last.author == author && @revisions.last.created_at + 30.minutes > 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

@@ -1,24 +1,23 @@
-# 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
+# Contains all the lock methods to be mixed in with the page
+module PageLock
+  LOCKING_PERIOD = 30 * 60 # 30 minutes
+
+  attr_reader :locked_by
+
+  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
+
 end

data/app/models/page_set.rb

@@ -1,64 +1,89 @@
-# 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
+# Container for a set of pages with methods for manipulation.
+
+class PageSet < Array
+  attr_reader :web
+
+  def initialize(web, pages = nil, condition = nil)
+    @web = web
+    # if pages is not specified, make a list of all pages in the web
+    if pages.nil?
+      super(web.pages.values)
+    # otherwise use specified pages and condition to produce a set of pages
+    elsif condition.nil?
+      super(pages)
+    else
+      super(pages.select { |page| condition[page] })
+    end
+  end
+
+  def most_recent_revision
+    self.map { |page| page.created_at }.max || Time.at(0)
+  end
+
+
+  def by_name
+    PageSet.new(@web, sort_by { |page| page.name })
+  end
+
+  alias :sort :by_name
+
+  def by_revision
+    PageSet.new(@web, sort_by { |page| page.created_at }).reverse 
+  end
+  
+  def pages_that_reference(page_name)
+    self.select { |page| page.wiki_references.include?(page_name) }
+  end
+  
+  def pages_that_link_to(page_name)
+    self.select { |page| page.wiki_words.include?(page_name) }
+  end
+
+  def pages_that_include(page_name)
+    self.select { |page| page.wiki_includes.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
+  # Pages that refer to themselves and have no links from outside are oprphans.
+  def orphaned_pages
+    never_orphans = web.select.authors + ['HomePage']
+    self.select { |page|
+      if never_orphans.include? page.name
+        false
+      else
+        references = pages_that_reference(page.name)
+        references.empty? or references == [page]
+      end
+    }
+  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