ruwiki 0.9.0

data/lib/ruwiki/config.rb

@@ -0,0 +1,244 @@
+#--
+# 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: config.rb,v 1.17 2004/11/28 05:27:32 austin Exp $
+#++
+require 'ruwiki/exportable'
+
+  # Ruwiki configuration.
+class Ruwiki::Config
+  include Ruwiki::Exportable
+
+  CONFIG_NAME = 'ruwiki.conf'
+
+  exportable_group 'ruwiki-config'
+    # Sets or returns the logger. The logger, if set, must respond to the same
+    # methods as WEBrick::Logger.
+  attr_accessor :logger
+    # Sets or returns the time format whenever time is outputted in Ruwiki.
+    # Default is <tt>%H:%M:%S</tt> (23:59:59).
+  attr_accessor :time_format
+  exportable :time_format
+    # Sets or returns the date format whenever time is outputted in Ruwiki.
+    # Default is <tt>%Y.%m.%d</tt> (2004.08.04).
+  attr_accessor :date_format
+  exportable :date_format
+    # Sets or returns the date-time format whenever time is outputted in
+    # Ruwiki. Default is <tt>%Y.%m.%d %H:%M:%S</tt> (2004.08.04 23:59:59).
+  attr_accessor :datetime_format
+  exportable :datetime_format
+    # Adds additional information to the (rare) error reports. Defaults to
+    # +false+.
+  attr_accessor :debug
+  exportable :debug
+    # The default page for display when Ruwiki is called without any arguments.
+    # Defaults to +ProjectIndex+
+  attr_accessor :default_page
+  exportable :default_page
+    # The default project for display when Ruwiki is called without any
+    # arguments or a project specification. Defaults to +Default+
+  attr_accessor :default_project
+  exportable :default_project
+    # The authentication mechanism name as a String. Corresponds to
+    # a filename that will be found in ruwiki/auth. The authenticator must
+    # have a single class method, +authenticate+, which accepts the
+    # +request+, the +response+, and the +#auth_options+. This API is
+    # a draft API and is likely to change in future versions of Ruwiki. In
+    # this version of Ruwiki, only one authentication mechanism will be
+    # found -- for dealing with authenticating users already logged into
+    # RubyForge.
+  attr_accessor :auth_mechanism
+  exportable :auth_mechanism
+    # Options for the authentication mechanism as a Hash. This will be
+    # passed to the authenticator defined in +#auth_mechanism+. 
+  attr_accessor :auth_options
+  exportable :auth_options
+    # The storage type as a String. Corresponds to a filename that will be
+    # found in ruwiki/backend. NOTE: The yaml and marshal storage types have
+    # been removed from Ruwiki 0.9.0, to be replaced with a single storage
+    # type of Flatfiles. Now, the YAML and Marshal formats can be enabled by
+    # setting options in the @storage_options field.
+  attr_accessor :storage_type
+  exportable :storage_type
+    # The options for the specified storage type. This is a hash of hashes with
+    # auto-vifification. See the storage type for available options.
+  attr_reader   :storage_options
+  exportable   :storage_options
+    # The path for templates. Defaults to <tt>./templates/</tt>.
+  attr_accessor :template_path
+  exportable :template_path
+    # The name of the Wiki. Defaults to <tt>ruwiki</tt>
+  attr_accessor :title
+  exportable :title
+    # The email address of the webmaster for the Wiki. Defaults to +nil+.
+  attr_accessor :webmaster
+  exportable :webmaster
+    # The name of the Ruwiki CSS file. Defaults to <tt>ruwiki.css</tt>.
+  attr_accessor :css
+  exportable :css
+    # The template set. Templates are always named as
+    # <template_path>/<template_set>/<template_name>. Template filename. Must
+    # be reachable by File#read.
+  attr_accessor :template_set
+  exportable :template_set
+    # Ruwiki is internationalized. This method sets the Ruwiki error
+    # messages (and a few other messages) to the specified language Module.
+    # The language Module must have a constant Hash called +Message+
+    # containing a set of symbols and localized versions of the messages
+    # associated with them.
+    #
+    # If the file 'ruwiki/lang/es.rb' contains the module
+    # <tt>Ruwiki::Lang::ES</tt>, the error messages for RSS could be
+    # localized to Espa�ol thus:
+    #
+    #   require 'ruwiki/lang/es'
+    #   ...
+    #   wiki.config.language = Ruwiki::Lang::ES
+    #
+    # Localization is per wiki instance. In a servlet environment, this may
+    # mean that only a single language is recognised.
+    #
+    # See Ruwiki::Lang::EN for more information.
+  attr_accessor :language
+  exportable :language
+    # The message hash.
+  attr_reader   :message
+
+  def language=(ll) #:nodoc:
+    if ll.kind_of?(String)
+      @language = Ruwiki::Lang::const_get(ll.upcase)
+    else
+      @language = ll
+    end
+    @message = @language::Message
+  end
+
+  # Returns the specified template as a string.
+  def template(name)
+    File.read(File.join(@template_path, @template_set, "#{name.to_s}.tmpl"))
+  rescue Errno::ENOENT
+    raise ConfigError, message[:no_template_found] % [name.inspect, @template_set]
+  end
+
+  # Returns the CSS stylesheet content for the Wiki. This previously
+  # returned the <link> to the stylesheet, but instead returns a <style>
+  # block in the head so that the CSS is kept with the template set, which
+  # may be kept outside of the HTML area.
+  def css_link
+    %Q[<style type="text/css" media="screen,print">#{File.read(File.join(@template_path, @template_set, @css))}</style>]
+  end
+
+  # Creates a new configuration object.
+  def initialize(exportable = {})
+    rc = exportable['ruwiki-config'] || {}
+    @debug            = (rc['debug'] == "false") ? false : true
+    @default_project  = rc['default-project'] || "Default"
+    @default_page     = rc['default-page']    || "ProjectIndex"
+    @auth_mechanism   = rc['auth-mechanism']  || nil
+
+    case rc['auth-options']
+    when nil, ""
+      @auth_options   = {}
+    else
+      @auth_options   = Ruwiki::Exportable.load(rc['auth-options'])['default']
+    end
+
+    case rc['storage-type']
+    when nil, ""
+      @storage_type   = 'flatfiles'
+    else
+      @storage_type   = rc['storage-type']
+    end
+
+      # in 'type!name:<Tab>value\n' format.
+    if rc['storage-options'].nil? or rc['storage-options'].empty?
+      @storage_options = Hash.new { |hh, kk| hh[kk] = {} }
+    else
+      @storage_options = Ruwiki::Exportable.load(rc['storage-options'])
+      @storage_options.keys.each do |key|
+        @storage_options[key] = @storage_options.delete(key)
+      end
+    end
+    if @storage_options.empty?
+      @storage_options[@storage_type]['extension'] = "ruwiki"
+      @storage_options[@storage_type]['data-path'] = "./data"
+      @storage_options[@storage_type]['format']    = "exportable"
+    end
+
+    @storage_options.each_value do |vv|
+      if vv['extension'].nil? or vv['extension'].empty?
+        vv['extension'] = "ruwiki"
+      end
+      if vv['data-path'].nil? or vv['data-path'].empty?
+        vv['data-path'] = "./data"
+      end
+    end
+
+    @template_path    = rc['template-path']   || "./templates/"
+    @template_set     = rc['template-set']    || "default"
+    @css              = rc['css']             || "ruwiki.css"
+    @webmaster        = rc['webmaster']
+    @title            = rc['title']           || "Ruwiki"
+    @time_format      = rc['time-format']     || "%H:%M:%S"
+    @date_format      = rc['date-format']     || "%Y.%m.%d"
+    @datetime_format  = rc['datetime-format'] || "#{@date_format} #{@time_format}"
+    case rc['language']
+    when nil, ""
+      self.language   = Ruwiki::Lang::EN
+    else
+      self.language   = Ruwiki::Lang::const_get(rc['language'].upcase)
+    end
+  end
+
+  # Verifies that required configuration options are actually set. Right
+  # now, it only checks the values that are defaulted to +nil+.
+  def verify
+    raise ConfigError, message[:no_webmaster_defined] if @webmaster.nil? or @webmaster.empty?
+    raise ConfigError, message[:invalid_template_dir] % [@template_path] unless File.exists?(@template_path) and File.directory?(@template_path)
+    tt = File.join(@template_path, @template_set)
+    raise ConfigError, message[:no_template_set] % [@template_set] unless File.exists?(tt) and File.directory?(tt)
+  end
+
+  # Provides the canonical export hash.
+  def export
+    exportable = super
+
+    rc = exportable['ruwiki-config']
+
+    rc['auth-options'] = Ruwiki::Exportable.dump({ 'default' => rc['auth-options']})
+
+    rc['storage-options'] = Ruwiki::Exportable.dump(rc['storage-options'])
+    rc['storage-type'] = rc['storage-type'].to_s
+    rc['language']  = "#{rc['language']}".sub(/^.*?::([A-Z]+)$/, '\1').downcase
+    exportable
+  end
+
+  class << self
+    def write(file, config)
+      if file.respond_to?(:write)
+        file.puts(config.dump)
+      else
+        File.open(file, 'wb') { |ff| ff.puts(config.dump) }
+      end
+    end
+
+    def read(file)
+      data = nil
+      if file.respond_to?(:read)
+        data = file.read
+      else
+        File.open(file, 'rb') { |ff| data = ff.read }
+      end
+      hash = Ruwiki::Exportable.load(data)
+
+      Ruwiki::Config.new(hash)
+    end
+  end
+
+  class ConfigError < StandardError; end
+end

data/lib/ruwiki/exportable.rb

@@ -0,0 +1,192 @@
+#--
+# 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: exportable.rb,v 1.3 2004/09/21 02:44:22 austin Exp $
+#++
+
+  # == Synopsis
+  # Generalises a marshaling format that is easily read and edited by humans
+  # and is relatively easy to manage by software. When an attribute is marked
+  # #exportable, the name of the attribute is transformed and stored in
+  # a two-level hash, e.g.:
+  #
+  #   exportable_group 'group1'
+  #   exportable :var_1
+  #   exportable :var_2
+  #   exportable_group 'group2'
+  #   exportable :var_3
+  #   exportable :var_4
+  #
+  # Results in an exportable hash of:
+  #
+  #   { 'group1' =>
+  #     { 'var-1' => @var1,
+  #       'var-2' => @var2, },
+  #     'group2' =>
+  #     { 'var-3' => @var3,
+  #       'var-4' => @var4, }, }
+  #
+module Ruwiki::Exportable
+  class InvalidFormatError < RuntimeError; end
+
+  class << self
+      # Adds two methods and an attribute to the class that is including Exportable
+      #
+      # <tt>__exportables</tt>::    Contains the list of exportable symbols by group.
+      # <tt>exportable_group</tt>:: Defines the current group for exportable
+      #                             symbols. Default is 'default'.
+      # <tt>exportable</tt>::       Accepts two arguments, the attribute being
+      #                             exported and an option hash, containing the
+      #                             values :name and :group, where :name
+      #                             indicates the name of the attribute (so
+      #                             that the default name transformation is
+      #                             not applied) and :group overrides the
+      #                             current #exportable_group. By default, the
+      #                             name of the attribute is transformed such
+      #                             that underscores are converted to dashes
+      #                             (<tt>var_1</tt> becomes 'var-1').
+    def append_features(mod)
+      super
+
+      class << mod
+        attr_reader :__exportables
+
+        define_method(:exportable_group) do |name|
+          @__exportable_group = name || 'default'
+        end
+
+        define_method(:exportable) do |*symset|
+          symbol = symset.shift
+          options = symset.shift || {}
+
+          @__exportables ||= {}
+
+          options[:name]  ||= symbol.to_s.gsub(/_/, '-')
+          options[:group] ||= @__exportable_group || 'default'
+
+          @__exportables[options[:group]] ||= {}
+          @__exportables[options[:group]][options[:name]] = "@#{symbol.to_s}".intern
+        end
+      end
+    end
+
+      # Looks for comments. Comments may ONLY be on single lines.
+    COMMENT_RE  = %r{^#}
+      # Looks for newlines
+    NL_RE       = %r{\n}
+      # Looks for a line that indicates an exportable value. See #dump.
+    HEADER_RE   = %r{^([a-z][-a-z]+)!([a-z][-a-z]+):[ \t](.*)$}
+      # Looks for an indented group indicating that the last group is
+      # a multiline value.
+    FIRST_TAB   = %r{^[ \t]}
+
+      # Dumps the provided exportable hash in the form:
+      #
+      #   section!name:<Tab>Value
+      #   section!name:<Space>Value
+      #
+      # Multiline values are indented either one space or one tab:
+      #
+      #   section!name:<Tab>Value Line 1
+      #   <Tab>Value Line 2
+      #   <Tab>Value Line 3
+      #   <Tab>Value Line 4
+      #
+      # All values in the exportable hash are converted to string
+      # representations, so only values that can meaningfully be reinstantiated
+      # from string representations should be stored in the exportable hash. It
+      # is the responsibility of the class preparing the exportable hash
+      # through Exportable#export to make the necessary transformations.
+    def dump(export_hash)
+      dumpstr = ""
+
+      export_hash.keys.sort.each do |sect|
+        export_hash[sect].keys.sort.each do |item|
+          val = export_hash[sect][item].to_s.split(NL_RE).join("\n\t")
+          dumpstr << "#{sect}!#{item}:\t#{val}\n"
+        end
+      end
+
+      dumpstr
+    end
+
+      # Loads a buffer in the form provided by #dump into an exportable hash.
+      # Skips comment lines.
+    def load(buffer)
+      hash = {}
+      return hash if buffer.nil? or buffer.empty?
+
+        # Split the buffer and eliminate comments.
+      buffer = buffer.split(NL_RE).delete_if { |line| line =~ COMMENT_RE }
+
+      if HEADER_RE.match(buffer[0]).nil?
+        raise Ruwiki::Exportable::InvalidFormatError
+      end
+
+      sect = item = nil
+      
+      buffer.each do |line|
+        line.chomp!
+        match = HEADER_RE.match(line)
+
+          # If there is no match, add the current line to the previous match.
+          # Remove the leading \t, though.
+        if match.nil?
+          raise Ruwiki::Exportable::InvalidFormatError if FIRST_TAB.match(line).nil?
+          hash[sect][item] << "\n#{line.gsub(FIRST_TAB, '')}"
+        else
+          sect              = match.captures[0]
+          item              = match.captures[1]
+          hash[sect]      ||= {}
+          hash[sect][item]  = match.captures[2]
+        end
+      end
+
+      hash
+    end
+  end
+
+    # Converts #exportable attributes to an exportable hash, in the form:
+    #   { 'group1' =>
+    #     { 'var-1' => @var1,
+    #       'var-2' => @var2, },
+    #     'group2' =>
+    #     { 'var-3' => @var3,
+    #       'var-4' => @var4, }, }
+    #
+    # Classes that #include Exportable are encouraged to override export to
+    # ensure safe transformations of values. An example use might be:
+    #
+    #   class TimeClass
+    #     include Ruwiki::Exportable
+    #
+    #     def export
+    #       sym = super
+    #
+    #       sym['default']['time'] = sym['default']['time'].to_i
+    #       sym
+    #     end
+    #
+    # In this way, the 'time' value is converted to an integer rather than the
+    # default string representation.
+  def export
+    sym = {}
+
+    self.class.__exportables.each do |group, gval|
+      gname = group || @__exportable_group || 'default'
+      gsym = {}
+      gval.each do |name, nval|
+        val = self.instance_variable_get(nval)
+        gsym[name] = val unless val.nil?
+      end
+      sym[gname] = gsym
+    end
+
+    sym
+  end
+end

data/lib/ruwiki/handler.rb

@@ -0,0 +1,342 @@
+#--
+# 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: handler.rb,v 1.8 2004/11/28 05:27:32 austin Exp $
+#++
+class Ruwiki::Handler
+  class << self
+    # Generate a new Handler pair from a CGI request.
+    def from_cgi(cgi, output_stream = $stdout)
+      Ruwiki::Handler.new do |o|
+        o.request   = Ruwiki::Handler::CGIRequest.new(cgi)
+        o.response  = Ruwiki::Handler::CGIResponse.new(cgi, output_stream)
+      end
+    end
+
+      # Generate a new Handler pair from a WEBrick request.
+    def from_webrick(req, res)
+      Ruwiki::Handler.new do |o|
+        o.request   = Ruwiki::Handler::WEBrickRequest.new(req)
+        o.response  = Ruwiki::Handler::WEBrickResponse.new(res)
+      end
+    end
+  end
+
+    # Returns the handler's request object.
+  attr_accessor :request
+    # Returns the handler's response object.
+  attr_accessor :response
+
+    # Creates the handler pair.
+  def initialize(&block) #:yields: self
+    @request  = nil
+    @response = nil
+    yield self if block_given?
+  end
+
+    # Essentially a clone of WEBrick::Cookie for use with Ruwiki.
+  class Cookie
+    attr_reader :name
+    attr_accessor :value
+    attr_accessor :version
+
+    FIELDS = %w(domain path secure comment max_age expires)
+
+    FIELDS.each { |field| attr_accessor field.intern }
+
+    def initialize(name, value)
+      @name     = name
+      @value    = value
+      @version  = 0       # Netscape Cookie
+
+      FIELDS.each { |field| instance_variable_set("@#{field}", nil) }
+
+      yield self if block_given?
+    end
+
+    def expires=(t) #:nodoc:
+      @expires = if t.nil? or t.kind_of?(Time)
+                   t
+                 else
+                   Time.parse(t.to_s)
+                 end
+    end
+
+    def to_s
+      ret = "#{@name}=#{@value}"
+      ret << "; Version=#{@version.to_s}"               if @version > 0
+      ret << "; Domain=#{@domain}"                      if @domain
+      ret << "; Expires=#{CGI::rfc1123_date(@expires)}" if @expires
+      ret << "; Max-Age=#{CGI::rfc1123_date(@max_age)}" if @max_age
+      ret << "; Comment=#{@comment}"                    if @comment
+      ret << "; Path=#{@path}"                          if @path
+      ret << "; Secure"                                 if @secure
+      ret
+    end
+  end
+
+    # Represents an abstract incoming request. This insulates the rest of
+    # the code from knowing whether parameters are passed as part of the
+    # path, as parameters in the URL, or in some other fashion.
+  class AbstractRequest
+    def initialize(*args)
+    end
+  end
+
+    # Handles all requests from web applications.
+    #
+    # Subclasses should provide:
+    # @parameters::   Hash-like object that responds to #[] and #hash_key?]
+    # @environment::  Hash-like object that responds to #[]
+  class AbstractWebRequest < AbstractRequest
+    # The parameters provided via the web request.
+    attr_reader :parameters
+      # The environment provided to the web request.
+    attr_reader :environment
+      # The request path.
+    attr_reader :path
+
+      # The list of cookies.
+    attr_reader :cookies
+
+    def each_parameter #:yields parameter, value:
+      @parameters.each { |kk, vv| yield kk, vv }
+    end
+
+    def each_environment #:yields variable, value
+      @environment.each { |kk, vv| yield kk, vv }
+    end
+
+    def each_cookie #:yields name, value:
+      @cookies.each { |kk, vv| yield kk, vv }
+    end
+
+      # Return the URL of our server.
+    def server_url
+      res = "http://" # should detect whether we're in secure server mode.
+      if @environment['HTTP_HOST']
+      res << @environment['HTTP_HOST']
+      else
+        res << "#{@environment['SERVER_NAME']}:#{@environment['SERVER_PORT']}"
+      end
+    end
+
+      # Return the URL of this script.
+    def script_url
+      server_url << @environment['SCRIPT_NAME'].to_s
+    end
+
+      # Return the URL of this request.
+    def request_url
+      res = script_url
+      res << @environment['PATH_INFO'] if @environment['PATH_INFO']
+      query = @environment['QUERY_STRING']
+      res << "?#{@environment['QUERY_STRING']}" if query && !query.empty?
+      res
+    end
+
+      # Convert a file path into a URL
+    def make_url(project, path)
+      "#{server_url}/#{project}/#{path}"
+    end
+
+    def determine_request_path
+      @path = ""
+      return @path if @environment['PATH_INFO'].nil?
+      @path = @environment['PATH_INFO'].dup
+    end
+  end
+
+    # Request for CGI-based activity to ruwiki.
+  class CGIRequest < AbstractWebRequest
+    def initialize(cgi, output_stream = $stdout)
+      @environment    = ENV
+      @cgi            = cgi
+      @parameters     = {}
+      cgi.params.each { |kk, vv| @parameters[kk] = vv[0] }
+      @cookies        = {}
+      cgi.cookies.each do |name, cookie|
+        @cookies[name] = Ruwiki::Handler::Cookie.new(name, cookie.value) do |oc|
+          oc.version  = cookie.version if cookie.respond_to?(:version)
+          oc.domain   = cookie.domain
+          oc.path     = cookie.path
+          oc.secure   = cookie.secure
+          oc.comment  = cookie.comment if cookie.respond_to?(:comment)
+          oc.expires  = cookie.expires
+        end
+      end
+      super
+    end
+  end
+
+    # Request for WEBrick based servlet activity to ruwiki.
+  class WEBrickRequest < AbstractWebRequest
+    def initialize(req)
+      @environment  = req.meta_vars
+      @parameters   = req.query
+      @cookies      = {}
+      req.cookies.each do |rqc|
+        @cookies[rqc.name] = Ruwiki::Handler::Cookie.new(rqc.name, rqc.value) do |oc|
+          oc.version  = rqc.version
+          oc.domain   = rqc.domain
+          oc.path     = rqc.path
+          oc.secure   = rqc.secure
+          oc.comment  = rqc.comment
+          oc.expires  = rqc.expires
+          oc.max_age  = rqc.max_age
+        end
+      end
+      super
+    end
+  end
+
+    # Used to write responses in different execution environments such as
+    # CGI and Webrick.
+    #
+    # If you want to create a new response object, you'll need to implement
+    # #add_header, #write_headers, #write_cookies, and #<<.
+    #
+    # The Response object is instantiated with an output stream which must
+    # supply +<<+ and +puts+ methods.
+  class AbstractResponse
+    # Add to the list of headers to be sent back to the client.
+    def add_header(key, value)
+      raise "Not implemented"
+    end
+
+        # Write the accumulated headers back to the client.
+    def write_headers
+      raise "Not implemented"
+    end
+
+        # Write the string to the client.
+    def <<(string)
+      raise "Not implemented"
+    end
+
+    def add_cookies(*cookies)
+      cookies.each do |cookie|
+        @cookies << cookie
+      end
+    end
+
+    def write_cookies
+      raise "Not implemented"
+    end
+
+        # output_stream must respond to #<< and #puts.
+    def initialize(output_stream = $stdout)
+      @headers = {}
+      @cookies = []
+      @written = false
+      @status  = nil
+      @output_stream = output_stream
+    end
+
+    def written?
+      @written
+    end
+  end
+
+    # CGIResponse is the response object for CGI mode.
+  class CGIResponse < AbstractResponse
+    # output_stream must respond to #<< and #puts.
+    def initialize(cgi, output_stream = $stdout)
+      @cgi      = cgi
+      @done     = {
+        :headers  => false,
+        :cookies  => false,
+        :body     => false
+      }
+      super(output_stream)
+    end
+
+      # Add the header pair for later output as a CGI header.
+    def add_header(key, value)
+      @headers[key] = value
+    end
+
+      # Write the headers to the stream. The headers can only be written
+      # once.
+    def write_headers
+      return if @done[:headers]
+      @headers.each { |key, value| @output_stream.puts "#{key}: #{value}\r\n" }
+      write_cookies
+      @output_stream.puts
+      @done[:headers] = true
+    end
+
+      # Write the cookies to the stream. The cookies can only be written
+      # once.
+    def write_cookies
+      return if @done[:cookies]
+      @cookies.each do |cookie|
+        @output_stream.puts "Set-Cookie: #{cookie.to_s}"
+      end
+      @done[:cookes] = true
+    end
+
+      # Output the string to the stream provided.
+    def <<(string)
+      @output_stream << string
+      @written = true
+    end
+
+    def write_status(status)
+      unless status.nil?
+        @output_stream << status
+        @written = true
+      end
+    end
+  end
+
+    # WEBrickResponse is the response object for WEBrick servlet mode.
+  class WEBrickResponse < AbstractResponse
+    def initialize(webrick_response)
+      @response = webrick_response
+      @cookies  = []
+      @done     = {
+        :headers  => false,
+        :cookies  => false,
+        :body     => false
+      }
+    end
+
+    def add_header(key, value)
+      @response[key] = value
+    end
+
+      # Copy the cookies into the WEBrick::HTTPResponse cookies array.
+    def write_cookies
+      return if @done[:cookies]
+      @cookies.each do |cookie|
+        @response.cookies << cookie.to_s
+      end
+      @done[:cookes] = true
+    end
+
+    def write_headers
+      write_cookies
+        # Webrick will take care of this on its own.
+    end
+
+    def <<(string)
+      @response.body << string.to_s
+      @written = true
+    end
+
+    def write_status(status)
+      unless status.nil?
+        match = %r{^HTTP/(?:\d|\.)+ (\d+) .*}.match(status)
+        @response.status = match.captures[0]
+        @response.body << status
+        @written = true
+      end
+    end
+  end
+end