instiki 0.9.2 → 0.10.0

data/app/controllers/application.rb

@@ -0,0 +1,131 @@
+# The filters added to this controller will be run for all controllers in the application.
+# Likewise will all the methods added be available for all controllers.
+class ApplicationController < ActionController::Base
+
+  before_filter :set_utf8_http_header, :connect_to_model
+  after_filter :remember_location
+
+  # For injecting a different wiki model implementation. Intended for use in tests
+  def self.wiki=(the_wiki)
+    # a global variable is used here because Rails reloads controller and model classes in the 
+    # development environment; therefore, storing it as a class variable does not work
+    # class variable is, anyway, not much different from a global variable
+    $instiki_wiki_service = the_wiki
+    logger.debug("Wiki service: #{the_wiki.to_s}")
+  end
+
+  def self.wiki
+    $instiki_wiki_service
+  end
+
+  protected
+  
+  def authorized?
+    @web.nil? ||
+    @web.password.nil? || 
+    cookies['web_address'] == @web.password || 
+    password_check(@params['password'])
+  end
+
+  def check_authorization
+    if in_a_web? and needs_authorization?(@action_name) and not authorized? and 
+      redirect_to :controller => 'wiki', :action => 'login', :web => @web_name
+      return false
+    end
+  end
+
+  def connect_to_model
+    @action_name = @params['action'] || 'index'
+    @web_name = @params['web']
+    @wiki = wiki
+    if @web_name
+      @web = @wiki.webs[@web_name] 
+      if @web.nil?
+        render_text "Unknown web '#{@web_name}'", '404 Not Found'
+        return false
+      end
+    end
+    @page_name = @file_name = @params['id']
+    @page = @wiki.read_page(@web_name, @page_name) unless @page_name.nil?
+    @author = cookies['author'] || 'AnonymousCoward'
+    check_authorization
+  end
+
+  FILE_TYPES = {
+    '.exe' => 'application/octet-stream',
+    '.gif' => 'image/gif',
+    '.jpg' => 'image/jpeg',
+    '.pdf' => 'application/pdf',
+    '.png' => 'image/png',
+    '.txt' => 'text/plain',
+    '.zip' => 'application/zip'
+  } unless defined? FILE_TYPES
+
+  def send_file(file, options = {})
+    options[:type] ||= (FILE_TYPES[File.extname(file)] || 'application/octet-stream')
+    super(file, options)
+  end
+
+  def in_a_web?
+    not @web_name.nil?
+  end
+
+  def password_check(password)
+    if password == @web.password
+      cookies['web_address'] = password
+      true
+    else
+      false
+    end
+  end
+
+  def password_error(password)
+    if password.nil? or password.empty?
+      'Please enter the password.'
+    else 
+      'You entered a wrong password. Please enter the right one.'
+    end
+  end
+
+  def redirect_show(page_name = @page_name, web = @web_name)
+    redirect_to :web => web, :controller => 'wiki', :action => 'show', 
+        :id => (page_name || 'HomePage')
+  end
+
+  @@REMEMBER_NOT = ['locked', 'save', 'back', 'file', 'pic', 'import']
+  def remember_location
+    if @response.headers['Status'] == '200 OK'
+      unless @@REMEMBER_NOT.include? action_name or @request.method != :get
+        @session[:return_to] = @request.request_uri
+        logger.debug("Session ##{session.object_id}: remembered URL '#{@session[:return_to]}'")
+      end
+    end
+  end
+
+  def return_to_last_remembered
+    # Forget the redirect location
+    redirect_target, @session[:return_to] = @session[:return_to], nil
+    # then try to redirect to it
+    if redirect_target.nil?
+      logger.debug("Session ##{session.object_id}: no remembered redirect location, trying /")
+      redirect_to_url '/'
+    else
+      logger.debug("Session ##{session.object_id}: " +
+          "redirect to the last remembered URL #{redirect_target}")
+      redirect_to_url(redirect_target)
+    end
+  end
+
+  def set_utf8_http_header
+    @response.headers['Content-Type'] = 'text/html; charset=UTF-8'
+  end
+
+  def wiki
+    $instiki_wiki_service
+  end
+
+  def needs_authorization?(action)
+    not %w( login authenticate published rss_with_content rss_with_headlines ).include?(action)
+  end
+
+end

data/app/controllers/file_controller.rb

@@ -0,0 +1,129 @@
+require 'fileutils'
+require 'application'
+require 'instiki_errors'
+
+# Controller that is responsible for serving files and pictures.
+# Disabled in version 0.10
+
+class FileController < ApplicationController
+
+  layout 'default'
+  
+  before_filter :check_allow_uploads
+
+  def file
+    check_path
+    if @params['file']
+      # form supplied
+      file_yard.upload_file(@file_name, @params['file'])
+      flash[:info] = "File '#{@file_name}' successfully uploaded"
+      @web.refresh_pages_with_references(@file_name)
+      return_to_last_remembered
+    elsif file_yard.has_file?(@file_name)
+      send_file(file_yard.file_path(@file_name))
+    else
+      logger.debug("File not found: #{file_yard.files_path}/#{@file_name}")
+      # go to the template, which is a file upload form
+    end
+  end
+
+  def cancel_upload
+    return_to_last_remembered
+  end
+  
+  def pic
+    check_path
+    if @params['file']
+      # form supplied
+      file_yard.upload_file(@file_name, @params['file'])
+      flash[:info] = "Image '#{@file_name}' successfully uploaded"
+      @web.refresh_pages_with_references(@file_name)
+      return_to_last_remembered
+    elsif file_yard.has_file?(@file_name)
+      send_file(file_yard.file_path(@file_name))
+    else
+      logger.debug("Image not found: #{file_yard.files_path}/#{@file_name}")
+      render_action 'file'
+    end
+  end
+
+  def import
+    return if file_uploads_disabled?
+
+    check_authorization
+    if @params['file']
+      @problems = []
+      import_file_name = "#{@web.address}-import-#{Time.now.strftime('%Y-%m-%d-%H-%M-%S')}.zip"
+      file_yard.upload_file(import_file_name, @params['file'])
+      import_from_archive(file_yard.file_path(import_file_name))
+      if @problems.empty?
+        flash[:info] = 'Import successfully finished'
+      else
+        flash[:info] = "Import finished, but some pages were not imported:<li>" + 
+            @problems.join('</li><li>') + '</li>'
+      end
+      return_to_last_remembered
+    else
+      # to template
+    end
+  end
+
+  protected
+
+  def check_allow_uploads
+
+    # TODO enable file uploads again after 0.10 release
+    unless RAILS_ENV == 'test'
+      render_text 'File uploads are not ready for general use in Instiki 0.10', '403 Forbidden'
+      return false
+    end
+
+    unless @web.allow_uploads
+      render_text 'File uploads are blocked by the webmaster', '403 Forbidden'
+      return false
+    end
+  end
+
+
+  private 
+  
+  def check_path
+    raise Instiki::ValidationError.new("Invalid path: no file name") unless @file_name
+    raise Instiki::ValidationError.new("Invalid path: no web name") unless @web_name
+    raise Instiki::ValidationError.new("Invalid path: unknown web name") unless @web
+  end
+  
+  def file_yard
+    @wiki.file_yard(@web)
+  end
+
+  def import_from_archive(archive)
+    logger.info "Importing pages from #{archive}"
+    zip = Zip::ZipInputStream.open(archive)
+    while (entry = zip.get_next_entry) do
+      ext_length = File.extname(entry.name).length
+      page_name = entry.name[0..-(ext_length + 1)]
+      page_content = entry.get_input_stream.read
+      logger.info "Processing page '#{page_name}'"
+      begin
+        existing_page = @wiki.read_page(@web.address, page_name)
+        if existing_page
+          if existing_page.content == page_content
+            logger.info "Page '#{page_name}' with the same content already exists. Skipping."
+            next
+          else
+            logger.info "Page '#{page_name}' already exists. Adding a new revision to it."
+            wiki.revise_page(@web.address, page_name, page_content, Time.now, @author)
+          end
+        else
+          wiki.write_page(@web.address, page_name, page_content, Time.now, @author)
+        end
+      rescue => e
+        logger.error(e)
+        @problems << "#{page_name} : #{e.message}"
+      end
+    end
+    logger.info "Import from #{archive} finished"
+  end
+
+end

data/app/controllers/wiki_controller.rb

@@ -0,0 +1,354 @@
+require 'application'
+require 'fileutils'
+require 'redcloth_for_tex'
+require 'parsedate'
+
+class WikiController < ApplicationController
+
+  layout 'default', :except => [:rss_feed, :rss_with_content, :rss_with_headlines, :tex,  :export_tex, :export_html]
+
+  def index
+    if @web_name
+      redirect_show 'HomePage'
+    elsif not @wiki.setup?
+      redirect_to :controller => 'admin', :action => 'create_system'
+    elsif @wiki.webs.length == 1
+      redirect_show 'HomePage', @wiki.webs.values.first.address
+    else
+      redirect_to :action => 'web_list'
+    end
+  end
+
+  # Outside a single web --------------------------------------------------------
+
+  def authenticate
+    if password_check(@params['password'])
+      redirect_show('HomePage')
+    else 
+      flash[:info] = password_error(@params['password'])
+      redirect_to :action => 'login', :web => @web_name
+    end
+  end
+
+  def login
+    # to template
+  end
+  
+  def web_list
+    @webs = wiki.webs.values.sort_by { |web| web.name }
+  end
+
+
+  # Within a single web ---------------------------------------------------------
+
+  def authors
+    @authors = @web.select.authors
+  end
+  
+  def export_html
+    export_pages_as_zip('html') do |page| 
+      @page = page
+      @link_mode = :export
+      render_to_string 'wiki/print'
+    end
+  end
+
+  def export_markup
+    export_pages_as_zip(@web.markup) { |page| page.content }
+  end
+
+  def export_pdf
+    file_name = "#{@web.address}-tex-#{@web.revised_on.strftime('%Y-%m-%d-%H-%M-%S')}"
+    file_path = File.join(@wiki.storage_path, file_name)
+
+    export_web_to_tex "#{file_path}.tex"  unless FileTest.exists? "#{file_path}.tex"
+    convert_tex_to_pdf "#{file_path}.tex"
+    send_file "#{file_path}.pdf"
+  end
+
+  def export_tex
+    file_name = "#{@web.address}-tex-#{@web.revised_on.strftime('%Y-%m-%d-%H-%M-%S')}.tex"
+    file_path = File.join(@wiki.storage_path, file_name)
+    export_web_to_tex(file_path) unless FileTest.exists?(file_path)
+    send_file file_path
+  end
+
+  def feeds
+    @rss_with_content_allowed = rss_with_content_allowed?
+    # show the template
+  end
+
+  def list
+    parse_category
+    @pages_by_name = @pages_in_category.by_name
+    @page_names_that_are_wanted = @pages_in_category.wanted_pages
+    @pages_that_are_orphaned = @pages_in_category.orphaned_pages
+  end
+  
+  def recently_revised
+    parse_category
+    @pages_by_revision = @pages_in_category.by_revision
+  end
+
+  def rss_with_content
+    if rss_with_content_allowed?
+      render_rss(hide_description = false, *parse_rss_params)
+    else
+      render_text 'RSS feed with content for this web is blocked for security reasons. ' +
+        'The web is password-protected and not published', '403 Forbidden'
+    end
+  end
+
+  def rss_with_headlines
+    render_rss(hide_description = true, *parse_rss_params)
+  end
+
+  def search
+    @query = @params['query']
+    @title_results = @web.select { |page| page.name =~ /#{@query}/i }.sort
+    @results = @web.select { |page| page.content =~ /#{@query}/i }.sort
+    all_pages_found = (@results + @title_results).uniq
+    if all_pages_found.size == 1
+      redirect_show(all_pages_found.first.name)
+    end
+  end
+
+  # Within a single page --------------------------------------------------------
+  
+  def cancel_edit
+    @page.unlock
+    redirect_show
+  end
+
+  def edit
+    if @page.nil?
+      redirect_to :action => 'index'
+    elsif @page.locked?(Time.now) and not @params['break_lock']
+      redirect_to :web => @web_name, :action => 'locked', :id => @page_name
+    else
+      @page.lock(Time.now, @author)
+    end
+  end
+  
+  def locked
+    # to template
+  end
+  
+  def new
+    # to template
+  end
+
+  def pdf
+    page = wiki.read_page(@web_name, @page_name)
+    safe_page_name = @page.name.gsub(/\W/, '')
+    file_name = "#{safe_page_name}-#{@web.address}-#{@page.created_at.strftime('%Y-%m-%d-%H-%M-%S')}"
+    file_path = File.join(@wiki.storage_path, file_name)
+
+    export_page_to_tex("#{file_path}.tex") unless FileTest.exists?("#{file_path}.tex")
+    # NB: this is _very_ slow
+    convert_tex_to_pdf("#{file_path}.tex")
+    send_file "#{file_path}.pdf"
+  end
+
+  def print
+    @link_mode ||= :show
+    # to template
+  end
+
+  def published
+    if @web.published
+      @page = wiki.read_page(@web_name, @page_name || 'HomePage') 
+    else 
+      redirect_show('HomePage') 
+    end
+  end
+  
+  def revision
+    get_page_and_revision
+  end
+
+  def rollback
+    get_page_and_revision
+  end
+
+  def save
+    redirect_to :action => 'index' if @page_name.nil?
+    cookies['author'] = @params['author']
+
+    begin
+      page = @web.pages[@page_name]
+      if @web.pages[@page_name]
+        wiki.revise_page(
+            @web_name, @page_name, @params['content'], Time.now, 
+            Author.new(@params['author'], remote_ip)
+        )
+        page.unlock
+      else
+        wiki.write_page(
+            @web_name, @page_name, @params['content'], Time.now, 
+            Author.new(@params['author'], remote_ip)
+        )
+      end
+      redirect_show(@page_name)
+    rescue Instiki::ValidationError => e
+      page.unlock if defined? page
+      flash[:error] = e
+      return_to_last_remembered
+    end
+  end
+
+  def show
+    if @page
+      begin
+        render_action 'page'
+      # TODO this rescue should differentiate between errors due to rendering and errors in 
+      # the application itself (for application errors, it's better not to rescue the error at all)
+      rescue => e
+        logger.error e
+        if in_a_web?
+          redirect_to :web => @web_name, :action => 'edit',
+              :action_suffix => "#{@page_name}?msg=#{e.message}"
+        else
+          raise e
+        end
+      end
+    else
+      if not @page_name.nil? and not @page_name.empty?
+        redirect_to :web => @web_name, :action => 'new', :id => @page_name
+      else
+        render_text 'Page name is not specified', '404 Not Found'
+      end
+    end
+  end
+
+  def tex
+    @tex_content = RedClothForTex.new(@page.content).to_tex
+  end
+
+
+  private
+    
+  def convert_tex_to_pdf(tex_path)
+    # TODO remove earlier PDF files with the same prefix
+    # TODO handle gracefully situation where pdflatex is not available
+    begin
+      wd = Dir.getwd
+      Dir.chdir(File.dirname(tex_path))
+      logger.info `pdflatex --interaction=nonstopmode #{File.basename(tex_path)}`
+    ensure
+      Dir.chdir(wd)
+    end
+  end
+
+  def export_page_to_tex(file_path)
+    tex
+    File.open(file_path, 'w') { |f| f.write(render_to_string('wiki/tex')) }
+  end
+
+  def export_pages_as_zip(file_type, &block)
+
+    file_prefix = "#{@web.address}-#{file_type}-"
+    timestamp = @web.revised_on.strftime('%Y-%m-%d-%H-%M-%S')
+    file_path = File.join(@wiki.storage_path, file_prefix + timestamp + '.zip')
+    tmp_path = "#{file_path}.tmp"
+
+    Zip::ZipOutputStream.open(tmp_path) do |zip_out|
+      @web.select.by_name.each do |page|
+        zip_out.put_next_entry("#{CGI.escape(page.name)}.#{file_type}")
+        zip_out.puts(block.call(page))
+      end
+      # add an index file, if exporting to HTML
+      if file_type.to_s.downcase == 'html'
+        zip_out.put_next_entry 'index.html'
+        zip_out.puts <<-EOL
+          <html>
+            <head>
+              <META HTTP-EQUIV="Refresh" CONTENT="0;URL=HomePage.#{file_type}">
+            </head>
+          </html>
+        EOL
+      end
+    end
+    FileUtils.rm_rf(Dir[File.join(@wiki.storage_path, file_prefix + '*.zip')])
+    FileUtils.mv(tmp_path, file_path)
+    send_file file_path
+  end
+
+  def export_web_to_tex(file_path)
+    @tex_content = table_of_contents(@web.pages['HomePage'].content, render_tex_web)
+    File.open(file_path, 'w') { |f| f.write(render_to_string('wiki/tex_web')) }
+  end
+
+  def get_page_and_revision
+    @revision = @page.revisions[@params['rev'].to_i]
+  end
+
+  def parse_category
+    @categories = @web.categories
+    @category = @params['category']
+    if @categories.include?(@category)
+      @pages_in_category = @web.select { |page| page.in_category?(@category) }
+      @set_name = "category '#{@category}'"
+    else 
+      @pages_in_category = PageSet.new(@web).by_name
+      @set_name = 'the web'
+    end
+  end
+
+  def parse_rss_params
+    if @params.include? 'limit'
+      limit = @params['limit'].to_i rescue nil
+      limit = nil if limit == 0
+    else
+      limit = 15
+    end
+    start_date = Time.local(*ParseDate::parsedate(@params['start'])) rescue nil
+    end_date = Time.local(*ParseDate::parsedate(@params['end'])) rescue nil
+    [ limit, start_date, end_date ]
+  end
+  
+  def remote_ip
+    ip = @request.remote_ip
+    logger.info(ip)
+    ip
+  end
+
+  def render_rss(hide_description = false, limit = 15, start_date = nil, end_date = nil)
+    if limit && !start_date && !end_date
+      @pages_by_revision = @web.select.by_revision.first(limit)
+    else
+      @pages_by_revision = @web.select.by_revision
+      @pages_by_revision.reject! { |page| page.created_at < start_date } if start_date
+      @pages_by_revision.reject! { |page| page.created_at > end_date } if end_date
+    end
+    
+    @hide_description = hide_description
+    @response.headers['Content-Type'] = 'text/xml'
+    @link_action = @web.password ? 'published' : 'show'
+    
+    render 'wiki/rss_feed'
+  end
+
+  def render_tex_web
+    @web.select.by_name.inject({}) do |tex_web, page|
+      tex_web[page.name] = RedClothForTex.new(page.content).to_tex
+      tex_web
+    end
+  end
+
+  def render_to_string(template_name)
+    add_variables_to_assigns
+    render template_name
+    @performed_render = false
+    @template.render_file(template_name)
+  end
+  
+  def rss_with_content_allowed?
+    @web.password.nil? or @web.published
+  end
+  
+  def truncate(text, length = 30, truncate_string = '...')
+    if text.length > length then text[0..(length - 3)] + truncate_string else text end
+  end
+  
+end