Wiki2Go 1.14.0

data/lib/Web2Go/WebrickRequest.rb

@@ -0,0 +1,124 @@
+require 'Webrick/httputils'
+
+module Web2Go
+
+  class WebrickFile
+    def initialize(file)
+      @file = file
+    end
+
+    def filename
+      @file.filename
+    end
+
+    def content
+      @file.list[0]
+    end
+
+  end
+
+  class WebrickRequest
+
+    attr_reader :server_variable
+    attr_reader :params
+    attr_reader :user
+    attr_reader :authenticated
+
+    def initialize(request)
+      @request = request
+      @server_variable = request.meta_vars
+      @server_variable['SCRIPT_NAME'], @server_variable['PATH_INFO'] = split_script_and_path(clean(request.path))
+      find_user(request)      
+      @params = parse_parameters
+    end
+
+    def path
+      @server_variable['PATH_INFO']
+    end
+
+    def host
+      @request.host
+    end
+
+    def port
+      @request.port
+    end
+
+    def parameter(name,default_value=nil)
+      value = @params[name]
+      if value.nil? then
+        return default_value
+      else
+        return value[0]
+      end
+    end
+
+    def uploaded_file(name,pos=0)
+      file = @request.query[name]
+      if !file.nil? then
+        return WebrickFile.new(file)
+      end
+      nil
+    end
+
+
+    def cookie(name)
+      return @request.cookies.find { |cookie| cookie.name == name }
+    end
+
+    def cookies
+      @request.cookies
+    end
+    
+    private
+
+    def find_user(req)
+      @user = ENV['USER'] || ENV['USERNAME']
+      if @user.nil? or @user.length == 0 then
+        @user = req.peeraddr[2] 
+        if @user.nil? or @user.length == 0 then
+          @user = req.peeraddr[3]
+        end
+      end
+      @authenticated = true
+    end  
+
+    def add_parameters(form,values)
+      values.each { |key,value|
+        if form.has_key?(key)
+          form[key].push(value) 
+        else
+          form[key] = [ value ]
+        end
+      }
+      form
+    end
+
+    def parse_parameters
+      form = { }
+      form = add_parameters(form,WEBrick::HTTPUtils::parse_query(@request.body))
+      form = add_parameters(form,WEBrick::HTTPUtils::parse_query(@request.query_string))
+      form
+    end
+
+    def split_script_and_path(path)
+      if path =~ /\// then
+        path =~ /^([^\/]+)\/(.*)$/
+        return $1,$2
+      else
+        return path,""
+      end
+
+    end
+
+    def clean(path)
+      if path.nil? then
+        return ""
+      else
+        return path.squeeze('/').gsub(/^\//,'').gsub(/\/$/,'')
+      end
+    end
+
+  end
+
+end

data/lib/Web2Go/WebrickResponse.rb

@@ -0,0 +1,50 @@
+require 'Webrick/httputils'
+require 'Webrick/cookie'
+
+module Web2Go
+
+  class WebrickResponse
+
+    def initialize(response)
+      @response = response 
+    end
+
+    def body=(content)
+      @response.body=(content)
+    end
+
+    def content_type=(type)
+      @response['Content-Type'] = type
+    end
+
+    def redirect_to=(url)
+      @response.set_redirect(WEBrick::HTTPStatus[302],url)
+    end
+
+    def set_cookie(cookie)
+      @response.cookies.delete_if { |item| item.name == cookie.name }
+      @response.cookies.push(cookie)
+    end
+
+    def cookies
+      @response.cookies
+    end
+
+    def add_cookie(name,value,domain=nil,path=nil,expires=nil)
+      cookie = WEBrick::Cookie.new(name,value)
+      cookie.expires = expires unless expires.nil?
+      cookie.domain  = domain unless domain.nil?
+      cookie.path    = path unless path.nil?
+      set_cookie(cookie)
+    end
+
+    def add_cookies(cookies)
+      cookies.each do |cookie|
+        set_cookie(cookie)
+      end
+    end
+
+  end
+
+end
+

data/lib/Wiki2Go.rb

@@ -0,0 +1,2 @@
+require 'Wiki2Go/Web.rb'
+require 'Wiki2Go/Wiki2Go.rb'

data/lib/Wiki2Go/BlackList.rb

@@ -0,0 +1,52 @@
+
+module Wiki2Go
+  
+  class BlackList
+    
+    attr_reader :name
+    
+    def initialize(name,items)
+      @name   = name
+      items = items.collect {|line| 
+        line.strip!
+        (line.empty? || line[0] == '#' ? nil : line)
+      }
+      @banned = items.compact
+    end
+    
+    def all
+      return @banned
+    end
+    
+    def add(item)
+      item = escape_regex(item)
+      @banned << item
+      @banned = @banned.sort.uniq
+    end
+    
+    def length
+      return @banned.length
+    end
+    
+    def contains(user)
+      match = @banned.find { |ban| user =~ Regexp.new(ban,Regexp::IGNORECASE) }
+      ! match.nil?
+    end
+    
+    def found_in(lines)
+      lines = lines.join(' ') if lines.kind_of? Array
+      @banned.each do | pattern |
+        match  = Regexp.new(pattern,Regexp::IGNORECASE)
+        return true if lines =~ match
+      end
+      return false
+    end
+    
+    private
+    
+    def escape_regex(item)
+      item.gsub(/\./,'\.')
+    end
+  end
+  
+end

data/lib/Wiki2Go/DotGraphics.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/ruby
+
+require 'English'
+
+module Wiki2Go
+
+  # 
+  # 
+
+  class DotGraphics
+
+    def initialize(path)
+      @path = path
+    end
+
+    def process(config,web,content)
+      config.log("Processing #{web.current_page}")
+      save_if_necessary(config,web,content,false)
+    end
+
+    def save(config,web,content)
+      config.log("Saving #{web.current_page}")
+      save_if_necessary(config,web,content,true)
+    end
+
+    private
+
+    def save_if_necessary(config,web,content,force)
+      image = content
+      result = ''
+      if image =~ /^([^\s]*)\s/ then
+        filename = $1
+        image = $POSTMATCH
+        image = image.gsub('\n',' ').gsub('\r',' ')
+        result = generate_image(config,web,filename,image,force)
+      end
+      result
+    end
+
+    def generate_image(config,web,filename,image,force)
+      path = config.site_directory
+      type = File.extname(filename).gsub(/\./,'')
+      fullname = File.join(path,web.name,'graphics',filename)
+      if force || !File.exists?(fullname) then
+        ensure_directory_exists(fullname)
+        config.log("Writing image file to #{fullname}")
+        write(image,type,fullname)
+      end
+      return "<img src=\"#{web.name}/graphics/#{filename}\" border=0 alt=\"#{filename}\">"
+    end
+
+
+    def write(graph,format,output)
+      cmdline = "#{File.join(@path,'dot')} -T#{format} -o#{output}" 
+      IO.popen(cmdline,"w+") do |f|
+        f.puts graph
+        f.close_write
+        f.read
+      end
+    end
+
+
+    def ensure_directory_exists(path)
+      dir,filename = File.split(path)
+      FileUtils.makedirs(dir) unless File.directory?(dir)
+    end
+  end
+
+end

data/lib/Wiki2Go/FileStorage.rb

@@ -0,0 +1,267 @@
+#!/usr/bin/ruby
+
+require 'Wiki2Go/Page.rb'
+require 'Wiki2Go/BlackList.rb'
+require 'Wiki2Go/WhiteList.rb'
+require 'Wiki2Go/GreyList.rb'
+
+require 'fileutils.rb'
+
+module Wiki2Go
+
+  class FileStorage
+
+    def initialize(dynamic_files,static_files)
+      @path = dynamic_files
+      @html = static_files
+    end
+
+    def exists?(path)
+      return FileTest.exists?(text_path(path,"txt"))
+    end
+
+    alias :exists :exists?
+
+    def load_page(subwiki,name)
+      lines = Array.new(1)
+      lines[0] = "" 
+      modified_time = Time.now
+      if exists(File.join(subwiki,name)) then
+        path = text_filename(subwiki,name,"txt") 
+        File.open(path) do |f|
+          lines = f.readlines
+          modified_time = File.mtime(path)
+        end
+      end
+      return Page.make_page(name,lines,modified_time)
+    end
+
+    def save_page(subwiki,page)
+      path    = text_filename(subwiki,page.title,"txt")
+      logfile = text_filename(subwiki,page.title,"log")
+      ensure_directory_exists(path)
+      append_current_text_to_logfile(path,logfile,page.author)
+      File.open(path,File::CREAT|File::TRUNC|File::RDWR) do |file|
+        page.write(file)
+      end
+    end
+
+    def save_spam(subwiki,name,content,author)
+      path = text_filename(subwiki,name,"spam")
+      ensure_directory_exists(path)
+      File.open(path,File::CREAT|File::APPEND|File::WRONLY) do |file|
+        file.puts("=== SPAM by #{author} on #{Time.now.strftime("%d/%m/%Y %H:%M")} ===")
+        file.puts(content)
+        file.puts("$LASTMODIFIED:#{Time.now.to_i}$")
+        file.puts("$AUTHOR:#{author}$")
+      end
+    end
+
+    def save_html(subwiki,page, content)
+      path = File.join(@html,subwiki,page + ".html")
+      ensure_directory_exists(path)
+      File.open(path,File::CREAT|File::TRUNC|File::RDWR) do |file|
+        file.puts content
+      end
+    end
+
+    def store_page(subwiki,page)
+      save_page(subwiki,page)
+    end
+
+    def load_template(subwiki,name)
+      path = template_filename(subwiki,name)
+      template = ""
+      File.open(path) do |f|
+        template = f.gets(nil) 
+      end
+    end
+
+    def store_web_file(subwiki,page,content)
+      path = static_filename(subwiki,page)
+      ensure_directory_exists(path)
+      File.open(path,"wb") do |f|
+        f.puts content
+      end
+    end
+
+    def search(subwiki,phrase)
+      pages = Array.new
+      to_search_for = Regexp.new(phrase)
+      topics = all_pages_in(subwiki)
+      topics.each do |topic|
+        page = load_page(subwiki,topic)
+        page.lines.each do |line|
+          if line =~ to_search_for then
+            pages << page
+            break 
+          end
+        end
+      end
+      return pages
+    end
+
+    def all_pages_in(subwiki) 
+      textdir = text_directory(subwiki)
+      pattern = File.join(textdir,"**/*.txt")
+      dirlen = pattern.length - 8
+      files = Dir[pattern].sort {|a,b| File.mtime(b) <=> File.mtime(a) }
+      files = files.collect {|file| file[dirlen..-5] }
+      return files
+    end
+
+    def wikis
+      textdir = text_directory('')
+      pattern = File.join(textdir,"*")
+      dirs = Dir[pattern]
+      dirs = dirs.find_all { |name| 
+        FileTest.directory?(name) && name[0] != '.' && File.basename(name) != 'CVS' 
+      }
+      dirs = dirs.collect { |name| File.basename(name) }
+    end
+
+    def read_changes_in(subwiki,max_number,with_body) 
+      files = all_pages_in(subwiki)
+      nbfiles = (max_number < files.length ? max_number : files.length)
+      changed_pages = Array.new
+      for i in 0..nbfiles-1
+        changed_pages << load_page(subwiki,files[i])
+      end
+      return changed_pages
+    end
+
+    def all_versions_of(subwiki,topic)
+      logfile = text_filename(subwiki,topic,"log")
+      versions = Array.new
+      if File.exists?(logfile) then
+        pattern = /^\*\*\* Modified by (.*) \*\*$/
+        lines = Array.new
+        File.open(logfile,"r") do |f|
+          f.each do |line|
+            if line =~ pattern then
+              add_new_version_to(versions,topic,lines,File.mtime(logfile))
+              lines = Array.new
+            else
+              lines << line
+            end
+          end
+        end
+        add_new_version_to(versions,topic,lines,File.mtime(logfile))
+      end      
+
+      versions << load_page(subwiki,topic)
+      return versions.reverse
+    end
+
+    def load_blacklist(type = 'user')
+      filename = config_filename(type + "_blacklist","txt")
+      banned = Array.new
+      if File.exists?(filename) then
+        File.open(filename,"r") do |f|
+          banned = f.readlines
+        end
+      end
+      return BlackList.new(filename,banned)
+    end
+
+    def load_whitelist
+      filename = config_filename("whitelist","txt")
+      allowed = Array.new
+      if File.exists?(filename) then
+        File.open(filename,"r") do |f|
+          allowed = f.readlines
+        end
+      end
+      return WhiteList.new(allowed)
+    end
+
+    def load_greylist
+      filename = config_filename("greylist","txt")
+      listed = Array.new
+      if File.exists?(filename) then
+        File.open(filename,"r") do |f|
+          listed = f.readlines
+        end
+      end
+      return GreyList.new(filename,listed)
+    end
+
+    def save_list(list)
+      filename = list.name
+      ensure_directory_exists(filename)
+      File.open(filename,File::CREAT|File::TRUNC|File::RDWR) do |f|
+        f.puts list.all
+      end
+    end
+
+    private
+
+    def add_new_version_to(versions,topic,lines,modified_time)
+      if !lines.empty? then
+        page = Page.make_page(topic,lines,modified_time)
+        versions << page
+      end
+    end    
+
+    def append_current_text_to_logfile(file,logfile,author)
+      if File.exists?(file) then
+        File.open(file,"r") do |f|
+          text = f.read
+          File.open(logfile,"a") do |log|
+            log.puts "*** Modified by #{author} **"
+            log.puts text
+          end
+        end
+      end
+    end
+
+    def ensure_directory_exists(path)
+      dir,filename = File.split(path)
+      FileUtils.mkdir_p(dir,{ :mode => 0775}) unless File.directory?(dir)
+    end
+
+    def text_path(path,ext) 
+      dir = File.dirname(path)
+      file = File.basename(path) + '.' + ext
+      File.join(text_directory(dir),file)
+    end
+
+    def text_filename(subwiki,page,ext)
+      return File.join(text_directory(subwiki),"#{page}.#{ext}")
+    end
+
+    def text_directory(subwiki)
+      dir = File.join(@path,"texts",subwiki)
+      ensure_directory_exists(dir)
+      return dir
+    end
+
+    def config_filename(page,ext)
+      return File.join(config_directory,"#{page}.#{ext}")
+    end
+
+    def config_directory
+      dir = File.join(@path,"config")
+      ensure_directory_exists(dir)
+      return dir
+    end
+
+    def template_filename(subwiki,name)
+      template_dir = File.join(@path,"templates")
+      path = File.join(template_dir,subwiki,name)
+      if !File.exists?(path) then
+        path = File.join(template_dir,name)
+        if !File.exists?(path) then
+          path = File.join(File.dirname(__FILE__),"Install","templates",name)
+        end
+      end
+      return path
+    end
+
+    def static_filename(subwiki,name)
+      return File.join(@html,"html",subwiki,name)
+    end
+
+  end
+
+end