ruwiki 0.9.0

data/lib/ruwiki/auth.rb

@@ -0,0 +1,56 @@
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# $Id: auth.rb,v 1.2 2004/11/22 04:53:40 austin Exp $
+#++
+class Ruwiki::Auth
+  class << self
+    def [](name)
+      @delegate ||= {}
+
+      if @delegate.has_key?(name)
+        @delegate[name]
+      else
+        require "ruwiki/auth/#{name}"
+        @delegate[name] = Ruwiki::Auth.const_get(name.capitalize)
+      end
+    end
+  end
+
+  class Token
+    def initialize(name = nil, groups = [], permissions = {})
+      @user_name    = name
+      @groups       = groups
+      @permissions  = permissions
+    end
+
+    def found?
+      not @user_name.nil?
+    end
+
+    def name
+      @user_name
+    end
+
+    def member?(unix_group_name)
+      @groups.include?(unix_group_name)
+    end
+
+    def groups
+      @groups
+    end
+
+    def allowed?(action)
+      @permission[action]
+    end
+
+    def permissions
+      @permissions
+    end
+  end
+end

data/lib/ruwiki/auth/gforge.rb

@@ -0,0 +1,73 @@
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# $Id: gforge.rb,v 1.3 2004/11/28 23:28:15 austin Exp $
+#++
+
+begin
+  require 'gforge_auth'
+rescue LoadError
+  class GForgeAuthenticator
+    class AuthenticationResult
+      def initialize(name = nil, groups = [])
+        @user_name  = name
+        @groups     = groups
+      end
+
+      def found?
+        not @user_name.nil?
+      end
+
+      def user_name
+        raise "No session associated with the given key was found" unless found?
+        @user_name
+      end
+
+      def member?(unix_group_name)
+        raise "No session associated with the given key was found" unless found?
+        @groups.include?(unix_group_name) 
+      end
+
+      def groups
+        raise "No session associated with the given key was found" unless found?
+        @groups
+      end
+    end
+
+    def self.authenticate(sessionkey, options = {})
+      sql = %Q(SELECT user_name FROM users u, user_session us WHERE us.session_hash = '#{sessionkey}' AND us.user_id = u.user_id;)
+      res = %x{psql -q -t -U #{options['user']} #{options['pass']} -c \"#{sql}\"}
+      rows = res.split(/\n/)
+      return AuthenticationResult.new if rows.size != 1
+
+      user_name = rows[0].strip
+      sql       = %Q(SELECT unix_group_name FROM groups g, users u, user_group ug WHERE u.user_name = '#{user_name}' AND ug.user_id = u.user_id AND g.group_id = ug.group_id)
+
+      res       = %x(psql -q -t -U #{options['user']} #{options['pass']} -c \"#{sql}\")
+      groups    = []
+      res.split(/\n/).each {|row| groups << row.strip }
+      AuthenticationResult.new(user_name, groups)
+    end
+  end
+end
+
+class Ruwiki::Auth::Gforge < Ruwiki::Auth
+  def self.authenticate(request, response, options = {})
+    options['user'] = options['user'].gsub!(%r{^(\w+)}, '\1')
+    options['pass'] = options['pass'].gsub!(%r{^(\w+)}, '\1')
+    session_key = request.cookies['session_ser'].value[0].split(%r{-\*-})[-1]
+    token = GForgeAuthenticator.authenticate(session_key, options)
+    token = Ruwiki::Auth::Token.new(token.user_name, token.groups)
+    token.permissions.default = true if token.found?
+  rescue
+    token = Ruwiki::Auth::Token.new
+    token.permissions.default = false
+  ensure
+    return token
+  end
+end

data/lib/ruwiki/backend.rb

@@ -0,0 +1,318 @@
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# $Id: backend.rb,v 1.24 2004/11/28 02:26:57 austin Exp $
+#++
+
+begin
+  if defined?(Gem::Cache)
+    require_gem 'diff-lcs', '~> 1.1.2'
+  else
+    require 'diff/lcs'
+  end
+rescue LoadError => ex
+  $stderr.puts ex.message
+  raise
+end
+
+class Ruwiki
+    # The list of known backends.
+  KNOWN_BACKENDS  = %w(flatfiles)
+
+    # The Ruwiki backend delegator. Ruwiki will always instantiate a version
+    # of this class which delegates the actual method execution to the Backend
+    # class. Error handling is handled by capturing (and possibly forwarding)
+    # exceptions raised by the delegate class.
+  class BackendDelegator
+    def initialize(ruwiki, backend)
+      @message = ruwiki.config.message
+      @time_format = ruwiki.config.time_format || "%H:%M:%S"
+      @date_format = ruwiki.config.date_format || "%Y.%m.%d"
+      @datetime_format = ruwiki.config.datetime_format || "#{@date_format} #{@time_format}"
+      options = ruwiki.config.storage_options
+      options['default-page'] = ruwiki.config.default_page
+
+      unless Ruwiki::KNOWN_BACKENDS.include?(backend)
+        raise RuntimeError, @message[:backend_unknown] % [backend] 
+      end
+
+      beconst = backend.capitalize
+
+      require "ruwiki/backend/#{backend}"
+
+      beoptions = options[backend]
+      @delegate = Ruwiki::Backend.const_get(beconst).new(beoptions)
+    rescue Ruwiki::Backend::BackendError => ex
+      if ex.kind_of?(Array)
+        raise Ruwiki::Backend::BackendError.new(nil), @message[ex.reason[0]] % ex.reason[1]
+      else
+        raise
+      end
+    end
+  
+      # Retrieve the specified topic and project page. Calls Backend#load
+      # after verifying that the project exists.
+    def retrieve(topic, project = 'Default')
+      unless page_exists?(topic, project)
+        exported = Ruwiki::Page::NULL_PAGE.dup
+        exported['properties'] = {
+          'title'         => topic,
+          'topic'         => topic,
+          'project'       => project,
+          'create-date'   => Time.now,
+          'edit-date'     => Time.now,
+          'editable'      => true,
+          'indexable'     => true,
+          'entropy'       => 0.0,
+          'html-headers'  => [],
+          'version'       => 0
+        }
+        exported['page'] = {
+          'header'  => nil,
+          'footer'  => nil
+        }
+
+        if project_exists?(project)
+          exported['page']['content'] = ""
+        else
+          exported['page']['content'] = @message[:project_does_not_exist] % [project]
+        end
+        return exported
+      end
+
+      return @delegate.load(topic, project)
+    rescue Ruwiki::Backend::InvalidFormatError => ex
+      raise Ruwiki::Backend::BackendError.new(nil), @message[:page_not_in_backend_format] % [project, topic, @delegate.class]
+    rescue Errno::EACCES => ex
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:no_access_to_read_topic] % [project, topic]
+    rescue Exception => ex
+      mm = [project, topic, %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:cannot_retrieve_topic] % mm
+    end
+
+      # Stores the specified topic and project page.
+    def store(page)
+      @delegate.store(page)
+
+      # update change page
+      begin
+        recent_changes = nil
+        if (page.topic == 'RecentChanges')
+          recent_changes = page.dup
+        else
+          recent_changes = Page.new(retrieve('RecentChanges', page.project))
+        end
+
+        changeline = "\n; #{page.editor_ip} (#{Time.now.strftime(@datetime_format)}), #{page.topic} : #{page.edit_comment}"
+
+        # add changeline to top of page
+        recent_changes.content = changeline + (recent_changes.content || "")
+        @delegate.store(recent_changes)
+      rescue Exception => ex
+        raise "Couldn't save RecentChanges\n#{ex.backtrace}"
+      end
+    rescue Errno::EACCES => ex
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:no_access_to_store_topic] % [page.project, page.topic]
+    rescue Exception => ex
+      mm = [page.project, page.topic, %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:cannot_store_topic] % mm
+    end
+
+      # Destroys the specified topic and project page.
+    def destroy(page)
+      @delegate.destroy(page)
+    rescue Errno::EACCES => ex
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:no_access_to_destroy_topic] % [page.project, page.topic]
+    rescue Exception => ex
+      mm = [page.project, page.topic, %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:cannot_destroy_topic] % mm
+    end
+
+      # Releases the lock on the page.
+    def release_lock(page, address = 'UNKNOWN')
+      time    = Time.now.to_i
+      @delegate.release_lock(page, time, address)
+    rescue Ruwiki::Backend::BackendError
+      raise Ruwiki::Backend::BackendError.new(nil), @message[:cannot_release_lock] % [page.project, page.topic]
+    rescue Errno::EACCES, Exception => ex
+      mm = [page.project, page.topic, %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:error_releasing_lock] % mm
+    end
+
+      # Attempts to obtain a lock on the page. The lock 
+    def obtain_lock(page, address = 'UNKNOWN', timeout = 600)
+      time    = Time.now.to_i
+      expire  = time + timeout
+      @delegate.obtain_lock(page, time, expire, address)
+    rescue Ruwiki::Backend::BackendError
+      raise Ruwiki::Backend::BackendError.new(nil), @message[:cannot_obtain_lock] % [page.project, page.topic]
+    rescue Errno::EACCES, Exception => ex
+      mm = [page.project, page.topic, %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:error_creating_lock] % mm
+    end
+
+      # Checks to see if the project exists.
+    def project_exists?(project)
+      @delegate.project_exists?(project)
+    end
+
+      # Checks to see if the page exists.
+    def page_exists?(topic, project = 'Default')
+      @delegate.page_exists?(topic, project)
+    end
+
+      # Attempts to create the project.
+    def create_project(project)
+      @delegate.create_project(project)
+    rescue Ruwiki::Backend::ProjectExists => ex
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:project_already_exists] % [project]
+    rescue Errno::EACCES => ex
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:no_access_to_create_project] % [project]
+    rescue Exception => ex
+      mm = [project, %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:cannot_create_project] % mm
+    end
+
+      # Attempts to destroy the project.
+    def destroy_project(project)
+      @delegate.destroy_project(project)
+    rescue Errno::EACCES => ex
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:no_access_to_destroy_project] % [project]
+    rescue Exception => ex
+      mm = [project, %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:cannot_destroy_project] % mm
+    end
+
+    def search_all_projects(searchstr)
+      if @delegate.respond_to?(:search_all_projects)
+        @delegate.search_all_projects(searchstr) 
+      else
+        search_all_projects_default(searchstr)
+      end
+    end
+
+      # Attempts to search all projects. This is the default
+      # search_all_projects used unless the delegate implements
+      # a specialized search_all_projects.
+    def search_all_projects_default(searchstr)
+      hits = {}
+      list_projects.each do |project|
+        lhits = search_project(project, searchstr)
+          # Transform the keys from project local to global links.
+        lhits.each { |key, val| hits["#{project}::#{key}"] = val }
+      end
+      hits
+    end
+
+      # Attempts to search a project
+    def search_project(project, searchstr)
+        #TODO: Validate searchstr is a safe regexp?
+      @delegate.search_project(project, searchstr)
+    rescue Exception => ex
+      mm = [project, searchstr, ex.class, %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:search_project_fail] % mm
+    end
+
+      # Return an array of projects
+    def list_projects
+      @delegate.list_projects
+    rescue Errno::EACCES => ex
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:no_access_list_projects]
+    rescue Exception => ex
+      mm = ['', %Q~#{ex}<br />\n#{ex.backtrace.join('<br />\n')}~]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:cannot_list_projects] % mm
+    end
+
+      # Return an array of projects
+    def list_topics(projname)
+      @delegate.list_topics(projname)
+    rescue Errno::EACCES => ex
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:no_access_list_topics] % [projname]
+    rescue Exception => ex
+      mm = [projname, ex.message]
+      raise Ruwiki::Backend::BackendError.new(ex), @message[:cannot_list_topics] % mm
+    end
+  end
+
+    # The Ruwiki backend abstract class and factory.
+  class Backend
+    class ProjectExists < RuntimeError #:nodoc:
+    end
+    class InvalidFormatError < RuntimeError #:nodoc:
+    end
+    class BackendError < RuntimeError #:nodoc:
+      attr_reader :reason
+
+      def initialize(reason, *args)
+        if @reason.respond_to?(:message)
+          @reason = reason.message
+        else
+          @reason = reason
+        end
+      end
+    end
+    def initialize(storage_options)
+    end
+
+  private
+    NL_RE = %r{\n} #:nodoc:
+
+    def map_diffset(diffset)
+      diffset.map do |hunk|
+        if hunk.kind_of?(Array)
+          hunk.map { |change| change.to_a }
+        else
+          hunk.to_a
+        end
+      end
+    end
+
+      # Creates the current diff object. This is made from two
+      # Ruwiki::Page#export hashes.
+    def make_diff(oldpage, newpage)
+      oldpage = oldpage.export if oldpage.kind_of?(Ruwiki::Page)
+      newpage = newpage.export if newpage.kind_of?(Ruwiki::Page)
+
+      diff = Hash.new
+
+      newpage.keys.sort.each do |sect|
+        newpage[sect].keys.sort.each do |item|
+          oldval = oldpage[sect][item]
+          newval = newpage[sect][item]
+
+          case [sect, item]
+          when ['properties', 'html-headers']
+              # Protect against NoMethodError.
+            oldval ||= []
+            newval ||= []
+            val = Diff::LCS.sdiff(oldval, newval, Diff::LCS::ContextDiffCallbacks)
+          when ['ruwiki', 'content-version'], ['properties', 'version'],
+               ['properties', 'entropy']
+            val = Diff::LCS.sdiff([oldval], [newval], Diff::LCS::ContextDiffCallbacks)
+          when ['properties', 'create-date'], ['properties', 'edit-date']
+            val = Diff::LCS.sdiff([oldval.to_i], [newval.to_i], Diff::LCS::ContextDiffCallbacks)
+          else
+              # Protect against NoMethodError.
+            val = Diff::LCS.sdiff(oldval.to_s.split(NL_RE), newval.to_s.split(NL_RE), Diff::LCS::ContextDiffCallbacks)
+          end
+
+          (diff[sect] ||= {})[item] = map_diffset(val) unless val.nil? or val.empty?
+        end
+      end
+
+      diff_hash = {
+        'old_version' => oldpage['properties']['version'],
+        'new_version' => newpage['properties']['version'],
+        'edit-date'   => newpage['properties']['edit-date'].to_i,
+        'editor-ip'   => newpage['properties']['editor-ip'],
+        'editor'      => newpage['properties']['editor'],
+        'diff'        => diff
+      }
+    end
+  end
+end

data/lib/ruwiki/backend/flatfiles.rb

@@ -0,0 +1,217 @@
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# $Id: flatfiles.rb,v 1.25 2004/11/26 12:18:47 austin Exp $
+#++
+require 'ruwiki/exportable'
+
+  # Stores Ruwiki pages as flatfiles.
+class Ruwiki::Backend::Flatfiles < Ruwiki::Backend
+    # Initializes the Flatfiles backend. The known options for the Flatfiles
+    # backend are documented below.
+    #
+    # data-path::     The directory in which the wiki files will be found. By
+    #                 default, this is "./data/"
+    # extension::     The extension of the wiki files. By default, this is
+    #                 +nil+ in the backend.
+    # format::        The format of the files in the backend. By default,
+    #                 this is 'exportable', a tagged data format produced by
+    #                 Ruwiki::Exportable; alternative formats are 'yaml'
+    #                 (::YAML.dump) and 'marshal' (::Marshal.dump).
+    # default-page::  The default page for a project. By default, this is
+    #                 ProjectIndex. This is provided only so that the backend
+    #                 can make reasonable guesses.
+  def initialize(options)
+    @data_path = options['data-path'] || File.join(".", "data")
+    @extension = options['extension']
+    @format = case options['format']
+              when 'exportable', nil
+                Ruwiki::Exportable
+              when 'yaml'
+                ::YAML
+              when 'marshal'
+                ::Marshal
+              end
+
+    if @extension.nil?
+      @extension_re = /$/
+    else
+      @extension_re = /\.#{@extension}$/
+    end
+
+    @default_page   = options['default-page'] || "ProjectIndex"
+    if not (File.exists?(@data_path) and File.directory?(@data_path))
+      raise Ruwiki::Backend::BackendError.new([:flatfiles_no_data_directory, [@data_path]])
+    end
+
+    super
+  end
+
+    # Destroys the topic page.
+  def destroy(page)
+    pf = page_file(page.topic, page.project)
+    File.unlink(pf) if File.exists?(pf)
+  end
+
+    # Checks to see if the project exists.
+  def project_exists?(project)
+    pd = project_directory(project)
+    File.exists?(pd) and File.directory?(pd)
+  end
+
+    # Checks to see if the page exists.
+  def page_exists?(topic, project = 'Default')
+    pf = page_file(topic, project)
+    project_exists?(project) and File.exists?(pf)
+  end
+
+    # Tries to create the project.
+  def create_project(project)
+    pd = project_directory(project)
+    raise Ruwiki::Backend::ProjectExists if File.exists?(pd)
+    Dir.mkdir(pd)
+  end
+
+    # Tries to destroy the project.
+  def destroy_project(project)
+    pd = project_directory(project)
+    Dir.rmdir(pd) if File.exists?(pd) and File.directory?(pd)
+  end
+
+    # String search all topic names and content in a project and
+    # return a hash of topic hits.
+  def search_project(project, searchstr)
+    re_search = Regexp.new(searchstr, Regexp::IGNORECASE)
+
+    hits = Hash.new { |hh, kk| hh[kk] = 0 }
+    topic_list = list_topics(project)
+
+    return hits if topic_list.empty?
+
+      # search topic content
+    topic_list.each do |topic|
+        # search name
+      hits[topic] += topic.scan(re_search).size
+
+        # check content
+      page = load(topic, project) rescue Ruwiki::Page::NULL_PAGE
+      page['page'].each_value do |item|
+        item = item.join("") if item.kind_of?(Array)
+        item ||= ""
+        hits[topic] += item.scan(re_search).size
+      end
+    end
+
+    hits
+  end
+
+  def lock_okay?(page, time, address = 'UNKNOWN')
+    lockokay  = false
+    lockfile  = "#{page_file(page.topic, page.project)}.lock"
+
+    if File.exists?(lockfile)
+      data = File.read(lockfile).split(%r{!})
+        # If the lock belongs to this address, we don't care how old it is.
+        # Thus, release it.
+      lock_okay ||= (data[0].chomp == address)
+        # If the lock is older than 10 minutes, release it.
+      lock_okay ||= (data[1].to_i < time)
+    else
+      lockokay = true
+    end
+  end
+
+    # Attempts to obtain a lock on the topic page. This must return the lock
+  def obtain_lock(page, time, expire, address = 'UNKNOWN')
+    lock = "#{address}!#{expire}"
+
+    if lock_okay?(page, time, address)
+      File.open("#{page_file(page.topic, page.project)}.lock", 'wb') { |lfh| lfh.puts lock }
+    else
+      raise Ruwiki::Backend::BackendError.new(nil)
+    end
+    lock
+  end
+
+    # Releases the lock on the topic page.
+  def release_lock(page, time, address = 'UNKNOWN')
+    time = Time.now.to_i
+    lockfile = "#{page_file(page.topic, page.project)}.lock"
+
+    if lock_okay?(page, time, address)
+      File.unlink(lockfile) if File.exists?(lockfile)
+    else
+      raise Ruwiki::Backend::BackendError.new(nil)
+    end
+    true
+  end
+
+    # list projects found in data path
+  def list_projects
+    Dir[File.join(@data_path, "*")].select do |dd|
+      File.directory?(dd) and File.exist?(page_file(@default_page, File.basename(dd)))
+    end.map { |dd| File.basename(dd) }
+  end
+
+    # list topics found in data path
+  def list_topics(project)
+    pd = project_directory(project)
+    raise Ruwiki::Backend::BackendError.new(:no_project) unless File.exist?(pd)
+
+    Dir[File.join(pd, "*")].select do |ff|
+      ff !~ /\.rdiff$/ and ff !~ /\.lock$/ and File.file?(ff) and ff =~ @extension_re
+    end.map { |ff| File.basename(ff).sub(@extension_re, "") }
+  end
+
+  def project_directory(project) # :nodoc:
+    File.join(@data_path, project)
+  end
+
+  def page_file(topic, project = 'Default') # :nodoc:
+    if @extension.nil?
+      File.join(project_directory(project), topic)
+    else
+      File.join(project_directory(project), "#{topic}.#{@extension}")
+    end
+  end
+
+  def make_rdiff(page_file, new_page)
+    diff_file = "#{page_file}.rdiff"
+
+    old_page = self.class.load(pf) rescue Ruwiki::Page::NULL_PAGE
+
+    diffs = []
+    File.open(diff_file, 'rb') { |ff| diffs = Marshal.load(ff) } if File.exists?(diff_file)
+    diffs << make_diff(old_page, new_page)
+    changes = Marshal.dump(diffs)
+
+    File.open(diff_file, 'wb') { |ff| ff << changes }
+  end
+
+    # Provides a HEADER marker.
+    # Loads the topic page from disk.
+  def load(topic, project)
+    data = nil
+    File.open(page_file(topic, project), 'rb') { |ff| data = ff.read }
+
+    Ruwiki::Page::NULL_PAGE.merge(@format.load(data))
+  rescue Ruwiki::Exportable::InvalidFormatError, TypeError, ArgumentError
+    raise Ruwiki::Backend::InvalidFormatError
+  end
+
+    # Saves the topic page -- and its difference with the previous version
+    # -- to disk.
+  def store(page)
+    pagefile  = page_file(page.topic, page.project)
+    export    = page.export
+    newpage   = @format.dump(export)
+    make_rdiff(pagefile, export)
+
+    File.open(pagefile, 'wb') { |ff| ff.puts newpage }
+  end
+end