microengine 0.0.2 → 0.0.9

data/README

@@ -18,21 +18,10 @@ It's ideal for simple homepages.
 MicroEngine used only FastCGI, so your web server must be support it. 
 Apache must has mod_rewrite and mod_fastcgi modules.
 
-=== Gems
-
 # gem install microengine
 $ cd /SITE/DIR/
 $ microengine ./
 
-=== All-include package
-It is good choise for hosting where you hasn't root password or access to gem.
-Just download archive with all libraries and unpack it to neccesary dir.
-
-$ tar -xf microengine-*.tar.bz2
-$ mv microengine-* /SITE/DIR/
-$ cd /SITE/DIR/
-$ ./bin/microengine ./
-
 === Apache example config
 After install MicroEngine files you must add this information to Apache config
 file. Note, if .htaccess isn't support, you must copy content of

data/Rakefile

@@ -1,29 +1,17 @@
 require 'rake'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
 
 PKG_NAME = "microengine"
-PKG_VERSION = "0.0.2"
+PKG_VERSION = "0.0.9"
 
 RUBY_FORGE_PROJECT = "microengine"
 RUBY_FORGE_USER = "iskin"
 
-PKG_FILES = FileList[
-  "bin/*", 
-  "content/**/*", 
-  "layouts/**/*", 
-  "lib/microengine/**/*", 
-  "public/**/*",
-  "access.log",
-  "LICENSE",
-  "Rakefile",
-  "README"]
-
 # RDoc
 Rake::RDocTask.new do |rd|
   rd.main = "README"
-  rd.rdoc_files.include("README", "lib/microengine/*.rb")
+  rd.rdoc_files.include("README", "lib/*.rb")
   rd.title = "MicroEngine"
   rd.options << "--all"
 end
@@ -43,7 +31,18 @@ spec = Gem::Specification.new do |s|
   
   s.add_dependency 'fcgi'
   
-  s.files = PKG_FILES
+  s.files = FileList[
+    "bin/*", 
+    "config/**/*", 
+    "content/**/*", 
+    "layouts/**/*", 
+    "lib/**/*", 
+    "public/**/*",
+    "public/.htaccess",
+    "access.log",
+    "LICENSE",
+    "Rakefile",
+    "README"]
   s.require_path = 'lib'
   s.bindir = "bin"
   s.executables = ["microengine"]
@@ -57,10 +56,4 @@ end
 
 Rake::GemPackageTask.new(spec) do |pkg|
   pkg.gem_spec = spec
-end
-
-# All-include package
-Rake::PackageTask.new(PKG_NAME, PKG_VERSION) do |pkg|
-  pkg.need_tar_bz2 = true
-  pkg.package_files = PKG_FILES.include ["lib/fcgi/**/*", "cache"]
 end

data/bin/microengine

@@ -30,14 +30,13 @@ end
 distr = File.dirname(__FILE__) + '/../'
 
 if not File.exists? path + 'content/layout'
-  require 'rubygems'
-  if not Gem.cache.search 'microengine'.empty?
-    files = ["config/*", "content/**/*", "/layouts/**/*", "/lib/boot.rb", "public/**/*", "access.log", "README"]
-  else
-    puts "Microengine gem isn't installed. Type 'gem install microengine' to install it."
-    puts "Cloning MicroEngine to #{path}"
-    files = ["**/*"]
-  end
+  files = [
+    "config/*", 
+    "content/**/*", 
+    "layouts/**/*", 
+    "public/**/*", 
+    "access.log", 
+    "README"]
 
   begin
     files.each do |pattern|
@@ -56,9 +55,10 @@ if not File.exists? path + 'content/layout'
     FileUtils.chmod_R 0777, path + 'content/'
     FileUtils.chmod 0777, path + 'cache/'
     FileUtils.chmod 0777, path + 'access.log'
-  #rescue
-    #puts "Can't copy files. Ensure that you has permissions to write in #{path} ."
-    #Process.exit
+    FileUtils.chmod 0755, path + 'public/microengine.fcgi'
+  rescue
+    puts "Can't copy files. Ensure that you has permissions to write in #{path} ."
+    Process.exit
   end
 end
 

data/config/search spiders

@@ -0,0 +1,4 @@
+Googlebot
+Yahoo!
+msnbot
+Yandex

data/config/settings.yaml

@@ -0,0 +1,11 @@
+# MicroEngine configration
+
+# If you set 'memory' memory will be used to store pages cache.
+# On 'file' pages will be loaded from file cache.
+cache: memory
+
+# Language, wich will be returned if visitor didn't know any content languages
+default_language: en
+
+# Layout, which was be used in new page
+default_layout: default

data/config/shadow.yaml

@@ -0,0 +1,3 @@
+--- 
+salt: 1e8c7723f9dfeb49fda0c29daa33f04f25eac216
+hash: d1aaabc72e57ce85595ad098ce1975ad1cd4f95c

data/lib/{microengine/admin_page.rb → admin_page.rb}

@@ -166,7 +166,7 @@ module Microengine
     
     def load_translation
       @admin_langs = []
-      Dir.glob(MICROENGINE_ROOT + '/lib/microengine/html/*.yaml') do |file|
+      Dir.glob(File.dirname(__FILE__) + '/html/*.yaml') do |file|
         @admin_langs.push File.basename(file, '.yaml')
       end
       
@@ -176,13 +176,13 @@ module Microengine
         lang = @admin.dispatcher.language(@http, @admin_langs)
       end
       
-      @translation = YAML::load_file MICROENGINE_ROOT + "/lib/microengine/html/#{lang}.yaml"
+      @translation = YAML::load_file File.dirname(__FILE__) + "/html/#{lang}.yaml"
     end
     
     # Display admin HTML in page layout
     def display(view)
       header = "<title>#{@translation[view]['title']}</title>"
-      rhtml = IO.read MICROENGINE_ROOT + "/lib/microengine/html/#{view}.rhtml"
+      rhtml = IO.read File.dirname(__FILE__) + "/html/#{view}.rhtml"
       body = ERB.new(rhtml).result(binding)
       
       if 'editor' == view

data/public/.htaccess

@@ -0,0 +1,5 @@
+AddHandler fastcgi-script .fcgi
+
+RewriteEngine On
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ microengine.fcgi [QSA,L]

data/public/microengine.fcgi

@@ -2,4 +2,10 @@
 #
 # Load microengine and start FastCGI dispatcher
 
-require File.dirname(__FILE__) + '/../lib/boot.rb'
+MICROENGINE_ROOT = File.dirname(__FILE__) + '/..'
+
+require 'rubygems'
+gem 'microengine'
+require 'initializer'
+
+Microengine::Initializer.new

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: microengine
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2008-01-30 00:00:00 +03:00
+  version: 0.0.9
+date: 2008-02-01 00:00:00 +03:00
 summary: MicroEngine is a fast, simple and minimalistic site engine.
 require_paths: 
 - lib
@@ -30,6 +30,9 @@ authors:
 - Andrey "A.I." Sitnik
 files: 
 - bin/microengine
+- config/settings.yaml
+- config/search spiders
+- config/shadow.yaml
 - content/403
 - content/403/ru.body
 - content/403/ru.header
@@ -53,23 +56,23 @@ files:
 - layouts/default/ru.yaml
 - layouts/default/layout.rhtml
 - layouts/default/en.yaml
-- lib/microengine/file_cache.rb
-- lib/microengine/http.rb
-- lib/microengine/initializer.rb
-- lib/microengine/memory_cache.rb
-- lib/microengine/dispatcher.rb
-- lib/microengine/assambler.rb
-- lib/microengine/admin_exception.rb
-- lib/microengine/admin_page.rb
-- lib/microengine/html
-- lib/microengine/html/ru.yaml
-- lib/microengine/html/untranslater.rhtml
-- lib/microengine/html/editor.rhtml
-- lib/microengine/html/refresher.rhtml
-- lib/microengine/html/error.rhtml
-- lib/microengine/html/en.yaml
-- lib/microengine/html/deleter.rhtml
-- lib/microengine/admin.rb
+- lib/file_cache.rb
+- lib/http.rb
+- lib/initializer.rb
+- lib/memory_cache.rb
+- lib/dispatcher.rb
+- lib/assambler.rb
+- lib/admin_exception.rb
+- lib/admin_page.rb
+- lib/html
+- lib/html/ru.yaml
+- lib/html/untranslater.rhtml
+- lib/html/editor.rhtml
+- lib/html/refresher.rhtml
+- lib/html/error.rhtml
+- lib/html/en.yaml
+- lib/html/deleter.rhtml
+- lib/admin.rb
 - public/javascripts
 - public/images
 - public/styles
@@ -77,13 +80,11 @@ files:
 - public/styles/print.css
 - public/styles/screen.css
 - public/microengine.fcgi
+- public/.htaccess
 - access.log
 - LICENSE
 - Rakefile
 - README
-- lib/fcgi/fcgi.so
-- lib/fcgi/fcgi.rb
-- cache
 test_files: []
 
 rdoc_options: []

data/lib/fcgi/fcgi.rb

@@ -1,618 +0,0 @@
-=begin
-
-fcgi.rb 0.8.5 - fcgi.so compatible pure-ruby FastCGI library
-
-fastcgi.rb Copyright (C) 2001 Eli Green
-fcgi.rb    Copyright (C) 2002-2003 MoonWolf <moonwolf@moonwolf.com>
-fcgi.rb    Copyright (C) 2004 Minero Aoki
-
-=end
-trap('SIGTERM') { exit }
-trap('SIGPIPE','IGNORE')
-
-begin
-  raise LoadError if defined?(FCGI_PURE_RUBY) && FCGI_PURE_RUBY
-  require "fcgi.so"
-rescue LoadError
-  require 'socket'
-  require 'stringio'
-
-  class FCGI
-
-    def self::is_cgi?
-      begin
-        s = Socket.for_fd($stdin.fileno)
-        s.getpeername
-        false
-      rescue Errno::ENOTCONN
-        false
-      rescue Errno::ENOTSOCK, Errno::EINVAL
-        true
-      end
-    end
-
-    def self::each(&block)
-      f = default_connection()
-      Server.new(f).each_request(&block)
-    ensure
-      f.close if f
-    end
-
-    def self::each_request(&block)
-      f = default_connection()
-      Server.new(f).each_request(&block)
-    ensure
-      f.close if f
-    end
-
-    def self::default_connection
-      ::Socket.for_fd($stdin.fileno)
-    end
-
-
-
-    ProtocolVersion = 1
-
-    # Record types
-    FCGI_BEGIN_REQUEST = 1
-    FCGI_ABORT_REQUEST = 2
-    FCGI_END_REQUEST = 3
-    FCGI_PARAMS = 4
-    FCGI_STDIN = 5
-    FCGI_STDOUT = 6
-    FCGI_STDERR = 7
-    FCGI_DATA = 8
-    FCGI_GET_VALUES = 9
-    FCGI_GET_VALUES_RESULT = 10
-    FCGI_UNKNOWN_TYPE = 11
-    FCGI_MAXTYPE = FCGI_UNKNOWN_TYPE
-
-    FCGI_NULL_REQUEST_ID = 0
-
-    # FCGI_BEGIN_REQUSET.role
-    FCGI_RESPONDER = 1
-    FCGI_AUTHORIZER = 2
-    FCGI_FILTER = 3
-
-    # FCGI_BEGIN_REQUEST.flags
-    FCGI_KEEP_CONN = 1
-
-    # FCGI_END_REQUEST.protocolStatus
-    FCGI_REQUEST_COMPLETE = 0
-    FCGI_CANT_MPX_CONN = 1
-    FCGI_OVERLOADED = 2
-    FCGI_UNKNOWN_ROLE = 3
-
-
-    class Server
-
-      def initialize(server)
-        @server = server
-        @buffers = {}
-        @default_parameters = {
-          "FCGI_MAX_CONNS" => 1,
-          "FCGI_MAX_REQS"  => 1,
-          "FCGI_MPX_CONNS" => true
-        }
-      end
-
-      def each_request(&block)
-        graceful = false
-        trap("SIGUSR1") { graceful = true }
-        while true
-          begin
-            session(&block)
-          rescue Errno::EPIPE, EOFError
-            # HTTP request is canceled by the remote user
-          end
-          exit 0 if graceful
-        end
-      end
-      
-      def session
-        sock, addr = *@server.accept
-        return unless sock
-        fsock = FastCGISocket.new(sock)
-        req = next_request(fsock)
-        yield req
-        respond_to req, fsock, FCGI_REQUEST_COMPLETE
-      ensure
-        sock.close if sock and not sock.closed?
-      end
-
-      private
-
-      def next_request(sock)
-        while rec = sock.read_record
-          if rec.management_record?
-            case rec.type
-            when FCGI_GET_VALUES
-              sock.send_record handle_GET_VALUES(rec)
-            else
-              sock.send_record UnknownTypeRecord.new(rec.request_id, rec.type)
-            end
-          else
-            case rec.type
-            when FCGI_BEGIN_REQUEST
-              @buffers[rec.request_id] = RecordBuffer.new(rec)
-            when FCGI_ABORT_REQUEST
-              raise "got ABORT_REQUEST"   # FIXME
-            else
-              buf = @buffers[rec.request_id]   or next # inactive request
-              buf.push rec
-              if buf.ready?
-                @buffers.delete rec.request_id
-                return buf.new_request
-              end
-            end
-          end
-        end
-        raise "must not happen: FCGI socket unexpected EOF"
-      end
-
-      def handle_GET_VALUES(rec)
-        h = {}
-        rec.values.each_key do |name|
-          h[name] = @default_parameters[name]
-        end
-        ValuesRecord.new(FCGI_GET_VALUES_RESULT, rec.request_id, h)
-      end
-
-      def respond_to(req, sock, status)
-        split_data(FCGI_STDOUT, req.id, req.out) do |rec|
-          sock.send_record rec
-        end
-        split_data(FCGI_STDERR, req.id, req.err) do |rec|
-          sock.send_record rec
-        end if req.err.length > 0
-        sock.send_record EndRequestRecord.new(req.id, 0, status)
-      end
-
-      DATA_UNIT = 16384
-
-      def split_data(type, id, f)
-        unless f.length == 0
-          f.rewind
-          while s = f.read(DATA_UNIT)
-            yield GenericDataRecord.new(type, id, s)
-          end
-        end
-        yield GenericDataRecord.new(type, id, '')
-      end
-
-    end
-
-
-    class FastCGISocket
-      def initialize(sock)
-        @socket = sock
-      end
-
-      def read_record
-        header = @socket.read(Record::HEADER_LENGTH) or return nil
-        return nil unless header.size == Record::HEADER_LENGTH
-        version, type, reqid, clen, padlen, reserved = *Record.parse_header(header)
-        Record.class_for(type).parse(reqid, read_record_body(clen, padlen))
-      end
-
-      def read_record_body(clen, padlen)
-        buf = ''
-        while buf.length < clen
-          buf << @socket.read([1024, clen - buf.length].min)
-        end
-        @socket.read padlen if padlen
-        buf
-      end
-      private :read_record_body
-
-      def send_record(rec)
-        @socket.write rec.serialize
-        @socket.flush
-      end
-    end
-
-
-    class RecordBuffer
-      def initialize(rec)
-        @begin_request = rec
-        @envs = []
-        @stdins = []
-        @datas = []
-      end
-
-      def push(rec)
-        case rec
-        when ParamsRecord
-          @envs.push rec
-        when StdinDataRecord
-          @stdins.push rec
-        when DataRecord
-          @datas.push rec
-        else
-          raise "got unknown record: #{rec.class}"
-        end
-      end
-
-      def ready?
-        case @begin_request.role
-        when FCGI_RESPONDER
-          completed?(@envs) and
-          completed?(@stdins)
-        when FCGI_AUTHORIZER
-          completed?(@envs)
-        when FCGI_FILTER
-          completed?(@envs) and
-          completed?(@stdins) and
-          completed?(@datas)
-        else
-          raise "unknown role: #{@begin_request.role}"
-        end
-      end
-
-      def completed?(records)
-        records.last and records.last.empty?
-      end
-      private :completed?
-
-      def new_request
-        Request.new(@begin_request.request_id, env(), stdin(), nil, nil, data())
-      end
-
-      def env
-        h = {}
-        @envs.each {|rec| h.update rec.values }
-        h
-      end
-
-      def stdin
-        StringIO.new(@stdins.inject('') {|buf, rec| buf << rec.flagment })
-      end
-
-      def data
-        StringIO.new(@datas.inject('') {|buf, rec| buf << rec.flagment })
-      end
-    end
-
-
-    class Request
-      def initialize(id, env, stdin, stdout = nil, stderr = nil, data = nil)
-        @id = id
-        @env = env
-        @in = stdin
-        @out = stdout || StringIO.new
-        @err = stderr || StringIO.new
-        @data = data || StringIO.new
-      end
-
-      attr_reader :id
-      attr_reader :env
-      attr_reader :in
-      attr_reader :out
-      attr_reader :err
-      attr_reader :data
-
-      def finish   # for backword compatibility
-      end
-    end
-
-
-    class Record
-      # uint8_t  protocol_version;
-      # uint8_t  record_type;
-      # uint16_t request_id;     (big endian)
-      # uint16_t content_length; (big endian)
-      # uint8_t  padding_length;
-      # uint8_t  reserved;
-      HEADER_FORMAT = 'CCnnCC'
-      HEADER_LENGTH = 8
-
-      def self::parse_header(buf)
-        return *buf.unpack(HEADER_FORMAT)
-      end
-
-      def self::class_for(type)
-        RECORD_CLASS[type]
-      end
-
-      def initialize(type, reqid)
-        @type = type
-        @request_id = reqid
-      end
-
-      def version
-        ::FCGI::ProtocolVersion
-      end
-
-      attr_reader :type
-      attr_reader :request_id
-
-      def management_record?
-        @request_id == FCGI_NULL_REQUEST_ID
-      end
-
-      def serialize
-        body = make_body()
-        padlen = body.length % 8
-        header = make_header(body.length, padlen)
-        header + body + "\000" * padlen
-      end
-
-      private
-
-      def make_header(clen, padlen)
-        [version(), @type, @request_id, clen, padlen, 0].pack(HEADER_FORMAT)
-      end
-    end
-
-    class BeginRequestRecord < Record
-      # uint16_t role; (big endian)
-      # uint8_t  flags;
-      # uint8_t  reserved[5];
-      BODY_FORMAT = 'nCC5'
-
-      def BeginRequestRecord.parse(id, body)
-        role, flags, *reserved = *body.unpack(BODY_FORMAT)
-        new(id, role, flags)
-      end
-
-      def initialize(id, role, flags)
-        super FCGI_BEGIN_REQUEST, id
-        @role = role
-        @flags = flags
-      end
-
-      attr_reader :role
-      attr_reader :flags
-      
-      def make_body
-        [@role, @flags, 0, 0, 0, 0, 0].pack(BODY_FORMAT)
-      end
-    end
-
-    class AbortRequestRecord < Record
-      def AbortRequestRecord.parse(id, body)
-        new(id)
-      end
-
-      def initialize(id)
-        super FCGI_ABORT_REQUEST, id
-      end
-    end
-
-    class EndRequestRecord < Record
-      # uint32_t appStatus; (big endian)
-      # uint8_t  protocolStatus;
-      # uint8_t  reserved[3];
-      BODY_FORMAT = 'NCC3'
-
-      def self::parse(id, body)
-        appstatus, protostatus, *reserved = *body.unpack(BODY_FORMAT)
-        new(id, appstatus, protostatus)
-      end
-
-      def initialize(id, appstatus, protostatus)
-        super FCGI_END_REQUEST, id
-        @application_status = appstatus
-        @protocol_status = protostatus
-      end
-
-      attr_reader :application_status
-      attr_reader :protocol_status
-
-      private
-
-      def make_body
-        [@application_status, @protocol_status, 0, 0, 0].pack(BODY_FORMAT)
-      end
-    end
-
-    class UnknownTypeRecord < Record
-      # uint8_t type;
-      # uint8_t reserved[7];
-      BODY_FORMAT = 'CC7'
-
-      def self::parse(id, body)
-        type, *reserved = *body.unpack(BODY_FORMAT)
-        new(id, type)
-      end
-
-      def initialize(id, t)
-        super FCGI_UNKNOWN_TYPE, id
-        @unknown_type = t
-      end
-
-      attr_reader :unknown_type
-
-      private
-
-      def make_body
-        [@unknown_type, 0, 0, 0, 0, 0, 0, 0].pack(BODY_FORMAT)
-      end
-    end
-
-    class ValuesRecord < Record
-      def self::parse(id, body)
-        new(id, parse_values(body))
-      end
-
-      def self::parse_values(buf)
-        result = {}
-        until buf.empty?
-          name, value = *read_pair(buf)
-          result[name] = value
-        end
-        result
-      end
-      
-      def self::read_pair(buf)
-        nlen = read_length(buf)
-        vlen = read_length(buf)
-        return buf.slice!(0, nlen), buf.slice!(0, vlen)
-      end
-      
-      def self::read_length(buf)
-        if buf[0] >> 7 == 0
-        then buf.slice!(0,1)[0]
-        else buf.slice!(0,4).unpack('N')[0] & ((1<<31) - 1)
-        end
-      end
-
-      def initialize(type, id, values)
-        super type, id
-        @values = values
-      end
-
-      attr_reader :values
-
-      private
-
-      def make_body
-        buf = ''
-        @values.each do |name, value|
-          buf << serialize_length(name.length)
-          buf << serialize_length(value.length)
-          buf << name
-          buf << value
-        end
-        buf
-      end
-
-      def serialize_length(len)
-        if len < 0x80
-        then len.chr
-        else [len | (1<<31)].pack('N')
-        end
-      end
-    end
-
-    class GetValuesRecord < ValuesRecord
-      def initialize(id, values)
-        super FCGI_GET_VALUES, id, values
-      end
-    end
-
-    class ParamsRecord < ValuesRecord
-      def initialize(id, values)
-        super FCGI_PARAMS, id, values
-      end
-
-      def empty?
-        @values.empty?
-      end
-    end
-
-    class GenericDataRecord < Record
-      def self::parse(id, body)
-        new(id, body)
-      end
-
-      def initialize(type, id, flagment)
-        super type, id
-        @flagment = flagment
-      end
-
-      attr_reader :flagment
-
-      def empty?
-        @flagment.empty?
-      end
-
-      private
-
-      def make_body
-        @flagment
-      end
-    end
-
-    class StdinDataRecord < GenericDataRecord
-      def initialize(id, flagment)
-        super FCGI_STDIN, id, flagment
-      end
-    end
-
-    class StdoutDataRecord < GenericDataRecord
-      def initialize(id, flagment)
-        super FCGI_STDOUT, id, flagment
-      end
-    end
-
-    class DataRecord < GenericDataRecord
-      def initialize(id, flagment)
-        super FCGI_DATA, id, flagment
-      end
-    end
-
-    class Record   # redefine
-      RECORD_CLASS = {
-        FCGI_GET_VALUES    => GetValuesRecord,
-
-        FCGI_BEGIN_REQUEST => BeginRequestRecord,
-        FCGI_ABORT_REQUEST => AbortRequestRecord,
-        FCGI_PARAMS        => ParamsRecord,
-        FCGI_STDIN         => StdinDataRecord,
-        FCGI_DATA          => DataRecord,
-        FCGI_STDOUT        => StdoutDataRecord,
-        FCGI_END_REQUEST   => EndRequestRecord
-      }
-    end
-
-  end # FCGI class
-end # begin
-
-# There is no C version of 'each_cgi'
-# Note: for ruby-1.6.8 at least, the constants CGI_PARAMS/CGI_COOKIES
-# are defined within module 'CGI', even if you have subclassed it
-
-class FCGI
-  def self::each_cgi(*args)
-    require 'cgi'
-    
-    eval(<<-EOS,TOPLEVEL_BINDING)
-    class CGI
-      public :env_table
-      def self::remove_params
-        if (const_defined?(:CGI_PARAMS))
-          remove_const(:CGI_PARAMS)
-          remove_const(:CGI_COOKIES)
-        end
-      end
-    end # ::CGI class
-
-    class FCGI
-      class CGI < ::CGI
-        def initialize(request, *args)
-          ::CGI.remove_params
-          @request = request
-          super(*args)
-          @args = *args
-        end
-        def args
-          @args
-        end
-        def env_table
-          @request.env
-        end
-        def stdinput
-          @request.in
-        end
-        def stdoutput
-          @request.out
-        end
-      end # FCGI::CGI class
-    end # FCGI class
-    EOS
-    
-    if FCGI::is_cgi?
-      yield ::CGI.new(*args)
-    else
-      exit_requested = false
-      FCGI::each {|request|
-        $stdout, $stderr = request.out, request.err
-
-        yield CGI.new(request, *args)
-        
-        request.finish
-      }
-    end
-  end
-end