ruwiki 0.9.0

data/lib/ruwiki/utils.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# This file may be renamed to change the URI for the wiki.
+#
+# $Id: utils.rb,v 1.2 2004/09/27 04:48:27 austin Exp $
+#++
+
+  # So that Ruwiki doesn't have to be loaded in full to use the bloody thing.
+unless defined?(Ruwiki)
+  class Ruwiki
+    VERSION = "0.9.0"
+  end
+end
+
+module Ruwiki::Utils
+  RUN_PATH = Dir.pwd
+end

data/lib/ruwiki/utils/command.rb

@@ -0,0 +1,102 @@
+#!/usr/bin/env ruby
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# This file may be renamed to change the URI for the wiki.
+#
+# $Id: command.rb,v 1.3 2004/11/09 14:55:35 austin Exp $
+#++
+
+  # Implements the command pattern. Commands are used by the command-line
+class Ruwiki::Utils::CommandPattern
+  class AbstractCommandError < Exception; end
+  class UnknownCommandError < RuntimeError; end
+  class CommandAlreadyExists < RuntimeError; end
+  class MissingParameterError < ArgumentError
+    def initialize(argument)
+      @argument = argument
+    end
+
+    attr_reader :argument
+  end
+
+  class << self
+    def add(command)
+      command = command.new if command.kind_of?(Class)
+
+      @commands ||= {}
+      if @commands.has_key?(command.name)
+        raise CommandAlreadyExists
+      else
+        @commands[command.name] = command
+      end
+
+      if command.respond_to?(:altname)
+        unless @commands.has_key?(command.altname)
+          @commands[command.altname] = command
+        end
+      end
+    end
+
+    def <<(command)
+      add(command)
+    end
+
+    attr_accessor :default
+    def default=(command) #:nodoc:
+      if command.kind_of?(Ruwiki::Utils::CommandPattern)
+      @default = command
+      elsif command.kind_of?(Class)
+        @default = command.new
+      elsif @commands.has_key?(command)
+        @default = @commands[command]
+      else
+        raise UnknownCommandError
+      end
+    end
+
+    def command?(command)
+      @commands.has_key?(command)
+    end
+
+    def command(command)
+      if command?(command)
+        @commands[command]
+      else
+        @default
+      end
+    end
+
+    def [](cmd)
+      self.command(cmd)
+    end
+
+    def default_ioe(ioe = {})
+      ioe[:input]   ||= $stdin
+      ioe[:output]  ||= $stdout
+      ioe[:error]   ||= $stderr
+      ioe
+    end
+  end
+
+  def [](args, opts = {}, ioe = {})
+    call(args, opts, ioe)
+  end
+
+  def name
+    raise AbstractCommandError
+  end
+
+  def call(args, opts = {}, ioe = {})
+    raise AbstractCommandError
+  end
+
+  def help
+    raise AbstractCommandError
+  end
+end

data/lib/ruwiki/utils/converter.rb

@@ -0,0 +1,297 @@
+#!/usr/bin/env ruby
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# This file may be renamed to change the URI for the wiki.
+#
+# $Id: converter.rb,v 1.5 2004/11/26 12:18:47 austin Exp $
+#++
+
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+
+module Ruwiki::Utils::Converter
+  class << self
+    TARGETS = %w(flatfiles yaml marshal)
+
+      # Create the regular expressions that are used in Ruwiki 0.6.2
+    OLD_HEADER_RE       = /^\s*([a-z]+)\s*:\s*(.*)$/
+    OLD_HEADER_END_RE   = /^#EHDR$/
+    DATA_HEADER_END_RE  = /\A#EHDR\z/
+    NL_RE               = /\n/
+
+    def with(obj)
+      yield obj if block_given?
+    end
+
+      # Only allow this to be run once. Silently fail otherwise.
+    def set_defaults
+      return unless @options.nil?
+      @options = OpenStruct.new
+
+      with @options do |oo|
+        oo.traverse_directories  = true
+        oo.backup_old_files      = true
+        oo.backup_extension      = "~"
+        oo.quiet                 = false
+        oo.verbose               = false
+        oo.extension             = 'ruwiki'
+        oo.target_format         = 'flatfiles'
+      end
+    end
+
+    def message=(lang)
+      if lang.kind_of?(Hash)
+        @message = lang
+      elsif "constant" == defined?(lang::Message)
+        @message = lang::Message
+      else
+        raise ArgumentError
+      end
+    end
+    def message(id)
+      if @message[id].nil?
+        []
+      else
+        @message[id]
+      end
+    end
+
+    def display_options
+    end
+
+    def summary
+    end
+
+    def run(argv, input = $stdin, output = $stdout, error = $stderr)
+      set_defaults
+
+      @input  = input
+      @output = output
+      @error  = error
+
+      language = 'en'
+      find_lang = argv.grep(%r{^--lang})
+      find_lang.each do |ee|
+        if ee =~ %r{^--lang=}
+          language = ee.sub(%r{^--lang=}, '')
+        else
+          language = argv[argv.index(ee).succ]
+        end
+      end
+
+      require "ruwiki/lang/#{language.downcase}"
+      self.message = Ruwiki::Lang.const_get(language.upcase)
+
+      argv.options do |opts|
+        opts.banner = message(:converter_usage) % File.basename($0)
+        opts.separator ''
+        opts.on('--format=FORMAT', *message(:converter_format_desc)) do |ff|
+          @options.target_format = ff
+        end
+        opts.on('--[no-]backup', *message(:converter_backup_desc)) do |bb|
+          @options.backup_old_files = bb
+        end
+        opts.on('--backup-extension=EXTENSION', *message(:converter_backupext_desc)) do |ee|
+          if ee.nil? or ee.empty?
+            @error << message(:converter_backupext_error) << "\n" if ee.nil? or ee.empty?
+            @error << "#{opts}\n"
+            return 0
+          end
+          @options.backup_extension = ee
+        end
+        opts.on('--extension=EXTENSION', *message(:converter_extension_desc)) do |ee|
+          if ee.nil? or ee.empty?
+            @error << message(:converter_extension_error) << "\n" if ee.nil? or ee.empty?
+            @error << "#{opts}\n"
+            return 0
+          end
+          @options.extension = ee
+        end
+        opts.on('--no-extension', *message(:converter_noextension_desc)) do
+          @options.extension = nil
+        end
+        opts.on('--lang=LANG', *message(:converter_language_desc)) do |lang|
+          self.message = Ruwiki::Lang.const_get(lang.upcase)
+        end
+        opts.on('--quiet', *message(:converter_quiet_desc)) do |qq|
+          @options.quiet   = qq
+          @options.verbose = (not qq)
+        end
+        opts.on('--verbose', *message(:converter_verbose_desc)) do |vv|
+          @options.quiet   = (not vv)
+          @options.verbose = vv
+        end
+        opts.separator ''
+        opts.on_tail('--help', *message(:converter_help_desc)) do
+          @error << "#{opts}\n"
+          return 0
+        end
+
+        opts.parse!
+      end
+
+      if argv.empty?
+        @error << message(:converter_num_arguments) << "\n#{argv.options}\n" unless @options.quiet
+        return 127
+      end
+
+      display_options if @options.verbose
+
+      @options.target_format.capitalize!
+      @options.target_format_class = Ruwiki::Backend.const_get(@options.target_format)
+
+      argv.each { |file| process_file(file) }
+
+      summary if not @options.quiet
+    end
+
+      # Process a single file.
+    def process_file(file)
+      if @options.backup_old_files
+        return if file =~ /#{@options.backup_extension}/
+      end
+      @out << "#{file}: " unless @options.quiet
+
+      if File.directory?(file) and @options.traverse_directories
+        @out << message(:converter_directory) << "\n" unless @options.quiet
+        Dir.chdir(file) { Dir['*'].each { |entry| process_file(entry) } }
+      else
+        begin
+          page, page_format = load_page(file)
+          @out << message(:converter_converting_from) % [ page_format, @options.target_format ] if @options.verbose
+          save_page(file, page)
+          @out << message(:converter_done) << "\n" unless @options.quiet
+        rescue PageLoadException
+          @out << message(:converter_not_ruwiki) << "\n" unless @options.quiet
+        rescue PageSaveException
+          @out << message(:cannot_nosave_modified) << "\n" % [ file ] unless @options.quiet
+        end
+      end
+    end
+
+    def load_page(file)
+      data = File.read(file)
+      page_format = nil
+
+      if data =~ OLD_HEADER_END_RE
+        page_format = 'OldFlatfiles'
+
+        page = Ruwiki::Page::NULL_PAGE.dup
+
+        unless data.empty?
+          rawbuf = data.split(NL_RE).map { |ee| ee.chomp }
+
+          loop do
+            if rawbuf[0] =~ OLD_HEADER_END_RE
+              rawbuf.shift
+              break
+            end
+
+            match = OLD_HEADER_RE.match(rawbuf[0])
+
+            unless match.nil?
+              case match.captures[0]
+              when 'topic'
+                page['properties']['topic'] = match.captures[1]
+                page['properties']['title'] = match.captures[1]
+              when 'version'
+                page['properties']['version'] = match.captures[1].to_i
+              else
+                nil
+              end
+            end
+            rawbuf.shift
+          end
+
+          page['page']['content'] = rawbuf.join("\n")
+
+          with page['properties'] do |pp|
+            pp['project']    = File.basename(File.dirname(File.expand_path(file)))
+            pp['editable']   = true
+            pp['indexable']  = true
+            pp['entropy']    = 0.0
+          end
+        end
+      end
+
+        # Try Marshal
+      if page_format.nil?
+        begin
+          page = ::Marshal.load(data)
+          page_format = 'Marshal'
+        rescue Exception
+          nil
+        end
+      end
+
+        # Try YAML
+      if page_format.nil?
+        begin
+          page = ::YAML.load(data)
+          page_format = 'YAML'
+        rescue Exception
+          nil
+        end
+      end
+
+        # Try the Flatfiles format
+      if page_format.nil?
+        begin
+          page = Ruwiki::Backend::Flatfiles.load(data)
+          page_format = 'Exportable'
+        rescue Exception => ex
+          nil
+        end
+      end
+
+      if page_format.nil? # Cannot detect page type.
+        @error << @message[:converter_page_format_error] << "\n"
+        raise PageLoadException
+      end
+      [page, page_format]
+    rescue PageLoadException
+      raise
+    rescue Exception => ex
+      @error << %Q|#{ex.message}\n#{ex.backtrace.join("\n")}\n| if @options.verbose
+      raise PageLoadException
+    end
+
+    def save_page(file, page)
+      if @options.backup_extension != '~'
+        backup = "#{file}.#{@options.backup_extension}"
+      else
+        backup = "#{file}#{@options.backup_extension}"
+      end
+
+          # Always backup the file -- we are transactional.
+      FileUtils.cp(file, backup)
+
+      if @options.target_format == 'Marshal'
+        method = :print
+      else
+        method = :puts
+      end
+      File.open(file, 'wb') { |ff| ff.__send__(method, @options.target_format_class.dump(page)) }
+    rescue Exception => ex
+      FileUtils.mv(backup, file) if File.exists?(backup)
+      @error << %Q|#{ex.message}\n#{ex.backtrace.join("\n")}\n| if @options.verbose
+      raise PageSaveException
+    ensure
+      # If we aren't *supposed* to back up the file, then get rid of the
+      # backup.
+      if File.exists?(backup) and (not @options.backup_old_files)
+        FileUtils.rm(backup)
+      end
+    end
+
+    class PageLoadException < RuntimeError; end
+    class PageSaveException < RuntimeError; end
+  end
+end

data/lib/ruwiki/utils/manager.rb

@@ -0,0 +1,639 @@
+#!/usr/bin/env ruby
+#--
+# Ruwiki
+#   Copyright � 2002 - 2004, Digikata and HaloStatue
+#   Alan Chen (alan@digikata.com)
+#   Austin Ziegler (ruwiki@halostatue.ca)
+#
+# Licensed under the same terms as Ruby.
+#
+# This file may be renamed to change the URI for the wiki.
+#
+# $Id: manager.rb,v 1.10 2004/11/28 02:26:57 austin Exp $
+#++
+
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+require 'stringio'
+require 'zlib'
+require 'ruwiki/exportable'
+require 'ruwiki/utils/command'
+require 'ruwiki/config'
+
+begin
+  if defined?(Gem::Cache)
+    require_gem 'archive-tar-minitar', '~> 0.5.1'
+  else
+    require 'archive/tar/minitar'
+  end
+rescue LoadError => ex
+  $stderr.puts ex.message
+  raise
+end
+
+module Ruwiki::Utils::Manager
+  DEFAULT_PACKAGE_NAME  = 'ruwiki.pkg'
+
+  def self.message=(lang)
+    if lang.kind_of?(Hash)
+      @message = lang
+    elsif "constant" == defined?(lang::Message)
+      @message = lang::Message
+    else
+      raise ArgumentError
+    end
+  end
+  def self.message(id)
+    @message[id]
+  end
+
+  class ManagerError < RuntimeError; end
+
+  EXECUTABLES = %w(ruwiki.cgi ruwiki_servlet ruwiki_servlet.bat \
+                   ruwiki_servlet.cmd ruwiki_service.rb)
+
+  class ManagerHelp < Ruwiki::Utils::CommandPattern
+    def name
+      "help"
+    end
+
+    def call(args, opts = {}, ioe = {})
+      ioe = Ruwiki::Utils::CommandPattern.default_ioe(ioe)
+      help_on = args.shift
+      output  = ""
+
+      if Ruwiki::Utils::CommandPattern.command?(help_on)
+        ioe[:output] << Ruwiki::Utils::CommandPattern[help_on].help
+      elsif help_on == "commands"
+        ioe[:output] << Ruwiki::Utils::Manager.message(:manager_help_commands)
+      else
+        ioe[:output] << Ruwiki::Utils::Manager.message(:manager_unknown_command) % [ help_on ] << "\n" % [ help_on ] unless help_on.nil? or help_on.empty?
+        ioe[:output] << self.help
+      end
+
+      0
+    end
+
+    def help
+      Ruwiki::Utils::Manager.message(:manager_help_help)
+    end
+  end
+
+  class ManagerInstall < Ruwiki::Utils::CommandPattern
+    def name
+      "install"
+    end
+
+    def call(args, opts = {}, ioe = {})
+      argv    = []
+
+      replace = false
+      dest    = "."
+      name    = nil
+
+      while (arg = args.shift)
+        case arg
+        when '--to'
+          dir = args.shift
+          raise Ruwiki::Utils::CommandPattern::MissingParameterError.new(arg) if dir.nil?
+          if File.exist?(dir)
+            if not File.directory?(dir)
+              raise ArgumentError, Ruwiki::Utils::Manager.message(:manager_dest_not_directory)
+            end
+          else
+            FileUtils.mkdir_p(dir)
+          end
+          dest = dir
+        when /;/o
+          argv.push(*(arg.split(/;/o)))
+        when /,/o
+          argv.push(*(arg.split(/,/o)))
+        else
+          argv << arg
+        end
+      end
+
+      options = { 'data' => true }
+
+      while (arg = argv.shift)
+        case arg
+        when /^(?:-|no)(.*$)/
+          options.delete($1)
+        else
+          options[arg] = true
+        end
+      end
+
+      Ruwiki::Utils::Manager.install(dest, options)
+
+      0
+    end
+
+    def help
+      Ruwiki::Utils::Manager.message(:manager_install_help)
+    end
+  end
+
+  class ManagerPackage < Ruwiki::Utils::CommandPattern
+    def name
+      "package"
+    end
+
+    def call(args, opts = {}, ioe = {})
+      ioe = Ruwiki::Utils::CommandPattern.default_ioe(ioe)
+      argv    = []
+      replace = false
+      dest    = "."
+      name    = nil
+
+      while (arg = args.shift)
+        case arg
+        when '--replace'
+          replace = true
+        when '-o', '--output'
+          name  = args.shift
+          raise Ruwiki::Utils::CommandPattern::MissingParameterError.new(arg) if name.nil?
+          dest  = File.dirname(name)
+          name  = File.basename(name)
+        else
+          argv << arg
+        end
+      end
+
+      if argv.size > 1
+        ioe[:output] << Ruwiki::Utils::Manager.message(:manager_service_hi_argcount) % [ args.join(" ") ] << "\n"
+        ioe[:output] << self.help
+        return 1
+      end
+      source = argv.shift || "."
+    
+      Ruwiki::Utils::Manager.package(source, dest, name, replace)
+      0
+    end
+
+    def help
+      Ruwiki::Utils::Manager.message(:manager_package_help) % [ "./#{Ruwiki::Utils::Manager::DEFAULT_PACKAGE_NAME}",
+                                                 Ruwiki::Config::CONFIG_NAME ]
+    end
+  end
+
+  class ManagerUnpackage < Ruwiki::Utils::CommandPattern
+    def name
+      "unpackage"
+    end
+
+    def call(args, opts = {}, ioe = {})
+      ioe = Ruwiki::Utils::CommandPattern.default_ioe(ioe)
+      argv    = []
+      dir     = "."
+
+      while (arg = args.shift)
+        case arg
+        when '-o', '--output'
+          dir = args.shift
+          raise Ruwiki::Utils::CommandPatter::MissingParameterError.new(arg) if dir.nil? or not File.directory?(dir)
+        else
+          argv << arg
+        end
+      end
+
+      if argv.size > 1
+        ioe[:output] << Ruwiki::Utils::Manager.message(:manager_service_hi_argcount) % [ args.join(" ") ] << "\n"
+        ioe[:output] << self.help
+        return 1
+      end
+      source = argv.shift || Ruwiki::Utils::Manager::DEFAULT_PACKAGE_NAME
+
+      Ruwiki::Utils::Manager.unpackage(source, dir)
+
+      0
+    end
+
+    def help
+      Ruwiki::Utils::Manager.message(:manager_unpackage_help) % [ "./#{Ruwiki::Utils::Manager::DEFAULT_PACKAGE_NAME}" ]
+    end
+  end
+
+  if RUBY_PLATFORM =~ /win32/
+    class ManagerService < Ruwiki::Utils::CommandPattern
+      def name
+        "service"
+      end
+
+      def call(args, opts = {}, ioe = {})
+        ioe = Ruwiki::Utils::CommandPattern.default_ioe(ioe)
+
+        if args.size < 2
+          ioe[:output] << Ruwiki::Utils::Manager.message(:manager_service_lo_argcount) % [ args.join(" ") ] << "\n"
+          ioe[:output] << self.help
+          return 0
+        end
+
+        command = args.shift
+        service = args.shift
+
+        options ||= {}
+        options[:service_name] = service
+        options[:service_home] = File.expand_path(".")
+
+        argv  = []
+        while (arg = args.shift)
+          case arg
+          when "--rubybin"
+            options[:ruby_bin] = args.shift
+            raise Ruwiki::Utils::CommandPattern::MissingParameterError.new(arg) if options[:ruby_bin].nil?
+          when "--exec"
+            options[:service_bin] = args.shift
+            raise Ruwiki::Utils::CommandPattern::MissingParameterError.new(arg) if options[:service_bin].nil?
+          when "--home"
+            options[:service_home] = args.shift
+            raise Ruwiki::Utils::CommandPattern::MissingParameterError.new(arg) if options[:service_home].nil?
+          else
+            argv << arg
+          end
+        end
+
+        options[:service_desc] = args.join(" ") if args.size > 0
+
+        case command
+        when "install"
+          options[:service_install] = true
+        when "start"
+          options[:service_start] = true
+        when "stop"
+          options[:service_stop] = true
+        when "delete"
+          options[:service_delete] = true
+        else
+          raise ArgumentError, Ruwiki::Utils::Manager.message(:manager_unknown_command) % [ command ]
+        end
+
+        Ruwiki::Utils::Manager.manage_windows_service(options, ioe)
+
+        0
+      end
+
+      def help
+        Ruwiki::Utils::Manager.message(:manager_service_help)
+      end
+    end
+    Ruwiki::Utils::CommandPattern << ManagerService
+  end
+
+  Ruwiki::Utils::CommandPattern << ManagerHelp
+  Ruwiki::Utils::CommandPattern << ManagerInstall
+  Ruwiki::Utils::CommandPattern << ManagerPackage
+  Ruwiki::Utils::CommandPattern << ManagerUnpackage
+  Ruwiki::Utils::CommandPattern.default = Ruwiki::Utils::CommandPattern["help"]
+
+  class << self
+    attr_accessor :shared
+    attr_reader   :ruwiki_servlet
+    attr_reader   :ruwiki_servlet_bat
+    attr_reader   :ruwiki_servlet_cmd
+    attr_reader   :ruwiki_service
+    attr_reader   :ruwiki_cgi
+    attr_reader   :ruwiki_pkg
+    def shared=(shared)
+      @shared             = shared
+      @ruwiki_servlet     = File.join(@shared, "bin", "ruwiki_servlet")
+      @ruwiki_servlet_bat = File.join(@shared, "bin", "ruwiki_servlet.bat")
+      @ruwiki_servlet_cmd = File.join(@shared, "bin", "ruwiki_servlet.cmd")
+      @ruwiki_service     = File.join(@shared, "bin", "ruwiki_service.rb")
+      @ruwiki_cgi         = File.join(@shared, "bin", "ruwiki.cgi")
+      @ruwiki_pkg         = File.join(@shared, Ruwiki::Utils::Manager::DEFAULT_PACKAGE_NAME)
+    end
+
+    def with(obj)
+      yield obj if block_given?
+    end
+
+    def tar_files(list, name)
+      ff = StringIO.new
+      gz = Zlib::GzipWriter.new(ff)
+      to = Archive::Tar::Minitar::Output.new(gz)
+      list.each { |item| Archive::Tar::Minitar.pack_file(item, to) }
+      data = ff.string
+      group = {
+        :name   => name,
+        :data   => data,
+        :mode   => 0644,
+      }
+      return group
+    rescue Exception => ex
+      puts ex.message, ex.backtrace.join("\n")
+    ensure
+      to.close
+      group[:size] = group[:data].size
+    end
+
+    def package(source, dest, name = nil, replace = false)
+      # If the package name is nil, use the default name. If replace is
+      # false, then append a number on the end if the file already exists.
+      # Increment the number until we have a unique filename.
+      if name.nil?
+        pkg = File.join(dest, DEFAULT_PACKAGE_NAME)
+        if File.exists?(pkg) and (not replace)
+          pbn = "#{File.basename(DEFAULT_PACKAGE_NAME, '.pkg')}-%02d.pkg"
+          ii  = 1
+          while File.exists?(pkg)
+            pkg = File.join(dest, pbn % ii)
+            ii += 1
+          end
+        end
+      else
+        pkg = File.join(dest, name)
+        if File.exists?(pkg) and (not replace)
+          raise ManagerError, Ruwiki::Utils::Manager.message(:manager_package_exists)
+        end
+      end
+
+      files = []
+
+      if File.directory?(source)
+        Dir.chdir(source) do
+          if File.exists?(Ruwiki::Config::CONFIG_NAME)
+            cs = File.stat(Ruwiki::Config::CONFIG_NAME)
+            files << {
+              :name   => Ruwiki::Config::CONFIG_NAME,
+              :data   => File.read(Ruwiki::Config::CONFIG_NAME),
+              :mtime  => cs.mtime,
+              :mode   => 0644,
+              :size   => cs.size
+            }
+          end
+
+          EXECUTABLES.each do |ff|
+            if File.exists?(ff)
+              cs = File.stat(ff)
+              files << {
+                :name   => ff,
+                :data   => File.read(ff),
+                :mtime  => cs.mtime,
+                :mode   => 0755,
+                :size   => cs.size
+              }
+            end
+          end
+
+          f_data = Dir["data/**/**"].select { |dd| dd !~ /CVS\// }
+          f_data.unshift("data")
+          f_data.map! do |dd|
+            res = { :name => dd, :mode => 0644 }
+            if File.directory?(dd)
+              res[:mode] = 0755
+              res[:dir] = true
+            end
+            res
+          end
+
+          f_tmpl = Dir["templates/**/**"].select { |tt| tt !~ /CVS\// }
+          f_tmpl.unshift("templates")
+          f_tmpl.map! do |tt|
+            res = { :name => tt, :mode => 0644 }
+            if File.directory?(tt)
+              res[:mode] = 0755
+              res[:dir] = true
+            end
+            res
+          end
+
+          files << tar_files(f_data, "data.pkg")
+          files << tar_files(f_tmpl, "tmpl.pkg")
+        end
+      else
+        stat = File.stat(source)
+        files << {
+          :name   => File.basename(source),
+          :data   => File.read(source),
+          :mtime  => stat.mtime,
+          :mode   => 0644,
+          :size   => stat.size
+        }
+
+        EXECUTABLES.each do |ff|
+          ff = File.join(File.dirname(source), ff)
+          if File.exists?(ff)
+            cs = File.stat(ff)
+            files << {
+              :name   => ff,
+              :data   => File.read(ff),
+              :mtime  => cs.mtime,
+              :mode   => 0755,
+              :size   => cs.size
+            }
+          end
+        end
+
+        cc = Ruwiki::Exportable.load(files[0][:data])
+        tp = cc['ruwiki-config']['template-path']
+        tp = "./templates" if tp.nil? or tp.empty?
+        so = cc['ruwiki-config']['storage-options']
+
+        if so.nil? or so.empty?
+          dp = "./data"
+        else
+          so = Ruwiki::Exportable.load(so)
+          key = 'flatfiles'
+          dp = so[key]['data-path']
+        end
+
+        dp = "./data" if dp.nil? or dp.empty?
+        bndp = File.basename(dp)
+        bntp = File.basename(tp)
+
+        so[key]['data-path'] = bndp
+        cc['ruwiki-config']['storage-options'] = Ruwiki::Exportable.dump(so)
+        cc['ruwiki-config']['template-path'] = bntp
+        files[0][:data] = Ruwiki::Exportable.dump(cc)
+        files[0][:size] = files[0][:data].size
+
+        Dir.chdir(File.dirname(dp)) do
+          f_data = Dir["#{bndp}/**/**"].select { |dd| dd !~ /CVS\// }
+          f_data.map! { |dd| { :name => dd, :mode => 0644 } }
+          files << tar_files(f_data, "data.pkg")
+        end
+
+        Dir.chdir(File.dirname(tp)) do
+          f_tmpl = Dir["#{bntp}/**/**"].select { |tt| tt !~ /CVS\// }
+          f_tmpl.map! { |tt| { :name => tt, :mode => 0644 } }
+          files << tar_files(f_tmpl, "tmpl.pkg")
+        end
+      end
+
+      ff = File.open(pkg, "wb")
+      gz = Zlib::GzipWriter.new(ff)
+      tw = Archive::Tar::Minitar::Writer.new(gz)
+
+      files.each do |entry|
+        tw.add_file_simple(entry[:name], entry) { |os| os.write(entry[:data]) }
+      end
+
+      nil
+    rescue Exception => ex
+      puts ex, ex.backtrace.join("\n")
+    ensure
+      tw.close if tw
+      gz.close if gz
+    end
+
+    def unpackage(source, dest)
+      ff = File.open(source, "rb")
+      gz = Zlib::GzipReader.new(ff)
+      Archive::Tar::Minitar::Input.open(gz) do |it|
+        it.each do |entry|
+          case entry.full_name
+          when "data.pkg", "tmpl.pkg"
+            pkg   = StringIO.new(entry.read)
+            pkgz  = Zlib::GzipReader.new(pkg)
+            Archive::Tar::Minitar::Input.open(pkgz) do |inner|
+              inner.each { |item| inner.extract_entry(dest, item) }
+            end
+          else
+            it.extract_entry(dest, entry)
+          end
+        end
+      end
+
+      nil
+    end
+
+    def install(dest, options = {})
+      if options['servlet']
+        FileUtils.install(Ruwiki::Utils::Manager.ruwiki_servlet, dest, :mode => 0755)
+        if RUBY_PLATFORM =~ /win32/
+          if File.exists?(Ruwiki::Utils::Manager.ruwiki_servlet_bat)
+            FileUtils.install(Ruwiki::Utils::Manager.ruwiki_servlet_bat, dest, :mode => 0755)
+          end
+          if File.exists?(Ruwiki::Utils::Manager.ruwiki_servlet_cmd)
+            FileUtils.install(Ruwiki::Utils::Manager.ruwiki_servlet_cmd, dest, :mode => 0755)
+          end
+        end
+      end
+
+      if RUBY_PLATFORM =~ /win32/ and options['service']
+        FileUtils.install(Ruwiki::Utils::Manager.ruwiki_service, dest, :mode => 0755)
+      end
+
+      if options['cgi']
+        FileUtils.install(Ruwiki::Utils::Manager.ruwiki_cgi, dest, :mode => 0755)
+      end
+
+      if options['data']
+        unpackage(Ruwiki::Utils::Manager.ruwiki_pkg, dest)
+      end
+    end
+
+    if RUBY_PLATFORM =~ /win32/
+      begin
+        require 'win32/service'
+        require 'rbconfig'
+        HasWin32Service = true
+      rescue LoadError
+        HasWin32Service = false
+      end
+
+      # The work here is based on Daniel Berger's Instiki Service Tutorial.
+      # http://rubyforge.org/docman/view.php/85/107/instiki_service_tutorial.txt
+      def manage_windows_service(options, ioe)
+        raise Ruwiki::Utils::Manager.message(:manager_service_broken) unless HasWin32Service
+
+        service_name  = options[:service_name] || 'RuwikiSvc'
+
+        if options[:service_install]
+          service_home  = options[:service_home]
+
+          program       = options[:service_bin]
+          if program.nil? or program.empty?
+            program     = File.join(service_home, "ruwiki_service.rb")
+          elsif program !~ %r{[/\\]}
+            program     = File.join(service_home, program)
+          end
+          program       = %<"#{program}">
+
+          ruby          = options[:ruby_bin] || %<"#{File.join(Config::CONFIG['bindir'], 'ruby.exe')}">
+
+          service_desc  = options[:service_desc] || 'Ruwiki'
+
+          binpath       = "#{ruby} #{program}".tr('/', '\\')
+
+          service = Win32::Service.new
+          service.create_service do |svc|
+            svc.service_name      = service_name
+            svc.display_name      = service_desc
+            svc.binary_path_name  = binpath
+            svc.dependencies      = [] # Required because of a bug in Win32::Service
+          end
+          service.close
+          ioe[:output] << Manager.manager(:manager_service_installed) % [ service_name ] << "\n"
+        end
+
+        if options[:service_start]
+          Win32::Service.start(service_name)
+          started = false
+          while (not started)
+            status  = Win32::Service.status(service_name)
+            started = (status.current_state == "running")
+            break if started
+            ioe[:output] << Ruwiki::Utils::Manager.message(:manager_one_moment) % [ status.current_state ] << "\n"
+            sleep 1
+          end
+          ioe[:output] << Ruwiki::Utils::Manager.message(:manager_service_started) % [ service_name ] << "\n"
+        end
+
+        if options[:service_stop]
+          Win32::Service.stop(service_name)
+          stopped = false
+          while (not stopped)
+            status  = Win32::Service.status(service_name)
+            stopped = (status.current_state == "stopped")
+            break if stopped
+            ioe[:output] << Ruwiki::Utils::Manager.message(:manager_one_moment) % [ status.current_state ] << "\n"
+            sleep 1
+          end
+          ioe[:output] << Ruwiki::Utils::Manager.message(:manager_service_stopped) % [ service_name ] << "\n"
+        end
+
+        if options[:service_delete]
+          Win32::Service.stop(service_name) rescue nil
+          Win32::Service.delete(service_name)
+          ioe[:output] << Ruwiki::Utils::Manager.message(:manager_service_deleted) % [ service_name ] << "\n"
+        end
+      end
+    end
+
+    def run(argv, input = $stdin, output = $stdout, error = $stderr)
+      ioe = {
+        :input  => input,
+        :output => output,
+        :error  => error
+      }
+
+      language = 'en'
+      find_lang = argv.grep(%r{^--lang})
+      find_lang.each do |ee|
+        eepos = argv.index(ee)
+        if ee =~ %r{^--lang=}
+          language = ee.sub(%r{^--lang=}, '')
+        else
+          language = argv[eepos.succ]
+          argv.delete_at(eepos.succ)
+        end
+        argv.delete_at(eepos)
+      end
+
+      require "ruwiki/lang/#{language.downcase}"
+      Ruwiki::Utils::Manager.message = Ruwiki::Lang.const_get(language.upcase)
+
+      command = Ruwiki::Utils::CommandPattern[(argv.shift or "").downcase]
+      return command[argv, {}, ioe]
+    rescue Ruwiki::Utils::CommandPattern::MissingParameterError => ee
+      ioe[:error] << Ruwiki::Utils::Manager.message(:manager_missing_parameter) % [ ee.argument ] << "\n"
+      return 1
+    rescue ArgumentError, ManagerError => ee
+      ioe[:error] << ee.message << "\n"
+      return 1
+    end
+  end
+end