ruby-web 1.1.1

data/lib/web/config.rb

@@ -0,0 +1,50 @@
+module Web
+  VERSION = "1.0.0"  
+  
+  def Web::docroot= docroot
+    Web::config[:docroot] = docroot
+  end
+  
+  def Web::docroot
+    Web::config[:docroot]
+  end    
+
+  class Config
+    def initialize
+      @config = {}
+      @docs = {}
+    end
+
+    attr_reader :docs
+
+    def [] (key)
+      @config[key.to_s]
+    end
+    
+    def []= (key, value)
+      @config[key.to_s] = value
+    end
+
+    def describe( info={} )
+      @docs.merge! info
+    end
+
+    def set( values={} )
+      @config.merge! values
+    end
+
+    def method_missing( symbol, *args )
+      if args.empty?
+        self[symbol]
+      else
+        super( symbol, *args )
+      end
+    end
+  end
+
+  @@config = Config.new
+  def Web.config
+    @@config
+  end
+
+end

data/lib/web/connection.rb

@@ -0,0 +1,1070 @@
+require 'web/stringio'
+require 'web/session'
+require 'web/upload'
+require 'web/mime'
+
+class Exception
+    
+  def rbw_html
+    msg = "<b style='font-size:20px'>" + Web::html_encode(self.to_s).gsub(/\n/,"<br>") + "</b><br>"
+    msg += Time::now().to_s
+    msg
+  end
+
+  def rbw_backtrace
+    #application_trace_length = (Web::run_caller || []).length
+    #self.backtrace[0..(0-application_trace_length)]
+    self.backtrace
+  end
+
+  def rbw_backtrace_html
+    trace = self.rbw_backtrace
+    trace.unshift(self.to_s)
+
+      msg = <<-STYLE
+<style type="text/css">
+.columnHead {
+  background-color:CCCDDD;
+  text-align:center;
+  font-weight:bold;
+}
+.info {
+  text-align:center;
+}
+.info_row:hover{
+  background-color:F8FF80;
+}
+</style>
+STYLE
+      msg += "<p><table onMouseover=\"changeto(event, '#F8FF80')\" onMouseout=\"changeback(event, '#eeeeff')\">\n"
+      msg += "<tr><td class='columnHead'>File</td><td class='columnHead'>&nbsp;Line&nbsp;</td><td class='columnHead'>Method</td></tr>\n"
+      
+      trace.each do |level|
+        level = Web::parse_trace(level)
+        msg += "<tr class='info_row'>\n"
+        level.each{ |column| msg += "<td class='info'>" + (column || '') + "</td>\n" }
+        msg += "</tr>\n\n"
+      end
+      
+      msg += "</table>"
+      
+      msg
+    end
+
+    def rbw_to_s
+      str =  self.class.to_s + ": " + self.to_s + "\n";
+      str += self.rbw_backtrace.collect do |line|
+               "  " + line.chomp
+             end.join("\n")
+      str
+    end
+
+  
+end
+
+module Web
+  class << self
+    def method_missing(method, *args, &block)
+      connection.send(method,*args, &block)
+    end
+    
+    def connection= connection
+      Thread.current[:web_connection] = connection
+    end
+    
+    def connection( options={} )
+      unless Thread.current[:web_connection]
+        self.connection = Web::Connection::create(options)
+      end
+      
+      Thread.current[:web_connection]
+    end
+  end
+  
+
+
+  class Connection
+    def initialize( options={} )
+      apply_options( options )
+      parse_request
+      setup_variables
+    end
+    
+    def apply_options( options = {} )
+      @closed = false
+      @header_sent = false
+      @templates = [ ]
+
+      @options = options
+      options[:buffered] = true unless options.has_key? :buffered
+
+      @raw_post_data  = options[:raw_post_data]  || $stdin
+      @output         = options[:out]            || $stdout
+      @cookie         = options[:cookie]
+      @request        = options[:request]
+
+
+
+      # start error handler
+      if (options.has_key? :error_handler)
+        if ( options[:error_handler] )
+          @error_handler = options[:error_handler]
+        end
+      end
+      # end error handler
+      
+      # start env
+      @env          ||= ENV
+      @env            = Connection::downcase_env(@env)
+      if options[:env] && options[:env].kind_of?(Hash) && !options[:env].keys.empty?
+        @env          = Connection::downcase_env( @env.merge( options[:env] ) )
+      end
+      Web::Connection::ENV_KEYS.each { |symbol|
+        env[symbol.to_s.downcase] = options[symbol] if options[symbol]
+      }
+      # end env
+    end
+
+    def setup_variables
+      @local = {}
+      @application_loaded = false
+      
+      @cookie  = Connection::normalize(@cookie)
+      @post    = Connection::normalize(@post)
+      @get     = Connection::normalize(@get)
+      @request = Connection::normalize(@request || merge_get_and_post )
+
+      raw_post_data.rewind
+
+      # start output buffer
+      @content = StringIO.new
+      if (unbuffered?)
+        @buffer = @output
+      else
+        @buffer = BufferSet.new
+      end
+      @buffer.binmode if @buffer.respond_to? :binmode
+      # end output buffer
+      
+
+    end
+
+    def merge_get_and_post
+      var_order = [ :post, :get, :cookie ]
+      
+      if env["request_method"] == "POST"
+        var_order = [ :get, :post, :cookie ]
+      end
+      
+      @request = Hash.new( [ ] )
+      var_order.each do |namespace|
+        variables = self.send( namespace )
+        if variables
+          variables.each do |k,v|
+            @request[k] = [ ]
+            v.each do |e|
+              @request[k].push(e.dup) if e
+            end
+          end
+        end
+      end
+      
+      @request
+    end
+    
+    attr_reader :options, :local, :request, :cgd, :env, :raw_post_data, :output, :get, :post, :content, :cookie
+    attr_accessor :application_loaded, :templates, :run_caller
+
+    def session
+      # start session
+      @session ||= if (options.has_key? :session)
+                     options[:session]
+                   else
+                     Session.new( self, options )
+                   end
+      # end session
+    end
+
+    def trace_output
+      templater = Narflates.new(CGI.trace_output_template,{})
+      templater.parse(self,{ "parameters" => 
+                            request.collect { |key,value| { "key" => key, "value" => value } },
+                            "cookie" =>
+                            cookie.collect { |key,value| { "key" => key, "value" => value } },
+                            "session" =>
+                            session.collect { |key,value| { "key" => key, "value" => value } } })
+      flush
+    end
+
+    MULTIPLE_KEY = /\[\]\z/
+    
+    # access parameters.  If the key is array-style,
+    # aka param[], return the array.  Otherwise,
+    # return the joined string.
+    def [] (key)
+      if (MULTIPLE_KEY =~ key)
+        self.request[key]
+      else
+        single_param(key)
+      end
+    end
+
+    # set param at the given key.  This is useful to change state
+    # in your app without asking the browser to redirect
+    def []= (key, value)
+      unless value.kind_of? Array
+        value = [value]
+      end
+      request[key] = value
+    end
+
+    # If request[key][0] is a Web::Upload, returns that value.
+    # Otherwise it returns request[key].join( "," )
+    def single_param(key)
+      if (request[key].first.kind_of? Web::Upload)
+        request[key].first
+      else
+        request[key].join( "," )
+      end
+    end
+    
+    def split_params #:nodoc:
+      Web::Testing::MultiHashTree.new(request).fields
+    end
+    
+    # list the submitted params
+    def keys
+      request.keys
+    end
+    
+    # test whether a param was submitted
+    def key? (key)
+      request.has_key? key
+    end
+    
+    #----------------------------------
+    # Response methods
+    #----------------------------------
+    
+    # send header to the client, and flush any buffered output
+    def flush
+      unless unbuffered?
+        begin
+          content = ob_flush
+          send_header
+          @output << content
+        rescue Exception => e
+          # protect against errors in output buffers
+          @buffer = BufferSet.new
+          Web::report_error(e)
+          self.flush
+        end
+      end
+    end
+
+    # TODO: at_close handlers
+    # flushes the output and, if applicable, saves the session
+    def close
+      flush
+      @session ||= nil
+      @session.save if (@session.respond_to? :save)
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    # ----------------------------------
+    # Output buffers
+    
+    # Append output to client
+    [ :<<, :puts, :write, :print ].each{ |symbol|
+      define_method(symbol) { |*args|
+        send_header if (unbuffered?)
+        unless closed?
+          @content.send( symbol, args ) if unbuffered?
+          @buffer.send( symbol, args )
+        end
+      }
+    }
+
+    # Reset output buffer.  Fails if headers have been sent.
+    def clear()
+      if header_sent?
+        raise( Exception.new( "Can't call Web::clear()" ) )
+      else
+        unless unbuffered?
+          @buffer = BufferSet.new
+          @content = StringIO.new
+        end
+      end
+    end
+    
+    # This method will replace the contents
+    # of the output buffer by reading from
+    # the given filename.  If the content-type
+    # has not already been upset, it will try
+    # and guess an appropriate mime-type
+    # from the extension of the file.
+    def send_file( filename )
+      clear()
+      write( File.open( filename, 'rb' ) { |f| f.read } )
+      if self.content_type == "text/html"
+        self.content_type = Web::Mime::get_mimetype(filename)
+      end
+      Web::close()
+    end
+
+    def unbuffered?
+      ! @options[:buffered]
+    end
+
+    # returns the body content of the response
+    # (sans headers).
+    def get_content
+      #flush_buffers # (do I need to flush the buffers?)
+      @content.string
+    end
+    
+    def ob_start( &callback )
+      @buffer.ob_start(&callback)
+    end
+    alias :filter :ob_start 
+    
+    def ob_get_flush
+      result = @buffer.last.get_contents
+      ob_flush
+      result
+    end
+ 
+    [ :ob_flush, :ob_end_flush ].each do |symbol|
+      define_method(symbol) do |*args|
+        result = @buffer.send( symbol )
+        @content << result
+        result
+      end
+    end
+
+    [:ob_clean, :ob_end_clean, :ob_get_clean, :ob_get_contents,
+     :ob_get_length, :ob_get_level, :ob_list_handlers ].each{ |symbol|
+      define_method(symbol) { |*args|
+        if (args.empty?)
+          @buffer.send( symbol )
+        else
+          @buffer.send( symbol, args )
+        end
+      }
+    }
+
+    class BufferSet
+      def initialize
+        @buffer_stack = [ ]
+        @buffer_stack.push CallbackBuffer.new
+      end
+
+      def ob_list_handlers
+        @buffer_stack
+      end
+
+      def ob_get_level
+        @buffer_stack.length
+      end
+
+      def last
+        @buffer_stack.last
+      end
+
+      def ob_clean
+        last.clean
+      end
+
+      def ob_end_clean
+        unless @buffer_stack.empty?
+          @buffer_stack.pop
+          true
+        end
+      end
+
+      def ob_get_clean
+        unless @buffer_stack.empty?
+          @buffer_stack.pop.get_contents
+        end
+      end
+
+      def ob_get_contents
+        @buffer_stack.last.get_contents
+      end
+      
+      def ob_flush
+        result = nil
+        @buffer_stack.reverse.each do |b|
+          b << result if result
+          result = b.flush
+        end
+        #@buffer_stack = [ CallbackBuffer.new ]
+        result
+      end
+
+      def ob_end_flush
+        result = ob_flush
+        ob_end_clean
+        result
+      end
+
+      def ob_get_length
+        ob_get_contents.length
+      end
+     
+      def ob_start( &callback )
+        @buffer_stack.push( CallbackBuffer.new(&callback) )
+      end
+      
+      [ :<<, :puts, :write, :print ].each{ |symbol|
+        define_method(symbol) { |*args| 
+          @buffer_stack.last.send( symbol, args )
+        }
+      }
+
+    end
+    
+    class CallbackBuffer
+      attr_accessor :callback
+      def initialize( &callback )
+        @callback = callback
+        @buffer   = StringIO.new
+      end
+      
+      def flush
+        result = if @callback
+                   @callback.call(@buffer.string)
+                 else
+                   @buffer.string
+                 end
+        self.clean
+        result
+      end
+      
+      def get_contents
+        @buffer.string
+      end
+
+      def clean
+        @buffer = StringIO.new
+      end
+      
+      [ :<<, :puts, :write, :print ].each{ |symbol|
+        define_method(symbol) { |*args| 
+          @buffer.send( symbol, args )
+        }
+      }
+      
+    end
+
+    # -----------------------------------
+    # header methods
+
+    # There's a bit of special casing in here, for the follow reasons:
+    # * some headers should only be sent once.  If you add
+    #   Content-Encoding, Location, or Status, it will overwrite the old headers
+    #   instead of adding a second header
+    # * content-type is a strange header.  It is a combination of the content-type
+    #   and charset attributes.  setting content-type will cause the content-type
+    #   attribute to be set; setting charset will cause the charset attribute to
+    #   be set.
+    #
+    #   I don't know if this is the correct behavior.  Should this method assume that
+    #   the content-type set here is the full content type, and try to split the
+    #   header into it's two parts?
+    #
+    # * If the headers have been sent, this will throw a Web::Error
+    def add_header(name, value )
+      unless header_sent?
+        if (/content-encoding/i =~ name  )
+          header['Content-Encoding'] = [value]
+        elsif( /location/i =~ name )
+          header['Location'] = [value]
+        elsif( /status/i =~ name )
+          if /^\d*$/ =~ value.to_s
+            self.status = value
+          else
+            header['Status'] = [value]
+          end
+        elsif(/content-type/i =~ name)
+          header['Content-Type'] = [value]
+        elsif(/charset/i =~ name)
+          self.charset = value
+        else
+          header[name] ||= []
+          header[name].push value
+        end
+      else
+        raise Web::Error.new( "Can't add_header after header have been sent to client" )
+      end
+    end
+
+    # returns an array of header values set with the given name.
+    def get_header name
+      header.keys.find_all { |key|
+        key.downcase == name.downcase
+      }.collect{ |key|
+        header[key].dup
+      }.flatten
+    end
+
+    
+    # Send header to the client.  No more header values can be sent after this method is called!
+    def send_header
+      unless header_sent?
+        unless @options[:noheader]
+          send_header_implementation
+        end
+        @header_sent = true
+      end
+    end
+    
+    def send_header_implementation
+      if @options[:nph] || /IIS/.match(env["server_software"])
+        output << "#{ env['server_protocol'] || 'HTTP/1.0' }: "
+        output << "#{ header['Status'] }\r\n"
+        output << "Date: #{ Web::rfc1123_date(Time.now) }\r\n"
+        
+        header.delete("Status")
+        
+        unless header.has_key? "Server"
+          header["Server"] = [ env["server_software"] || "" ]
+        end
+      end
+      
+      header.sort.each { |name, value|
+        value.each { |v|
+          output << "#{ name }: #{ v }\r\n"
+        }
+      }
+      
+      output << "\r\n"
+    end
+    
+    def header_sent?
+      @header_sent
+    end
+    
+    def header 
+      @header ||= {"Content-Type" => ["text/html"],
+                   "Status" => ["200 OK"] }
+      @header
+    end
+    
+    # the default status is 200
+    def status
+      get_header( "Status" ).first =~ /^(\d+)( .*)?$/ 
+      $1
+    end
+
+    HTTP_STATUS = {"200" => "OK",
+                   "206" => "Partial Content",
+                   "300" => "Multiple Choices",
+                   "301" => "Moved Permanently",
+                   "302" => "Found",
+                   "304" => "Not Modified",
+                   "400" => "Bad Request",
+                   "401" => "Authorization Required",
+                   "403" => "Forbidden",
+                   "404" => "Not Found",
+                   "405" => "Method Not Allowed",
+                   "406" => "Not Acceptable",
+                   "411" => "Length Required",
+                   "412" => "Precondition Failed",
+                   "500" => "Internal Server Error",
+                   "501" => "Method Not Implemented",
+                   "502" => "Bad Gateway",
+                   "506" => "Variant Also Negotiates"
+    }
+    def status= new_status
+      add_header( "Status", "#{ new_status } #{ HTTP_STATUS[new_status.to_s] }" )
+    end
+
+    def location
+      get_header( "Location" ).first
+    end
+
+    # see set redirect
+    def location= location
+      add_header( "Location", location )
+    end
+    
+    # Sets the status and the location appropriately.
+    def set_redirect( new_location )
+      self.status = "302"
+      self.location = new_location
+    end
+    
+    def encoding
+      get_header( "Content-Encoding" ).first
+    end
+
+    def encoding=( new_encoding )
+      add_header( "Content-Encoding", new_encoding )
+    end
+
+    def split_content_type( target = full_content_type )
+      target.split( Regexp.new('; charset=') )
+    end
+
+    # The content type header is a combination of the content_type and the charset.
+    # This method returns that combination.
+    def full_content_type
+      get_header( "Content-Type" ).first
+    end
+
+    def set_full_content_type( new_content, new_charset )
+      add_header( "Content-type", [ new_content, new_charset ].compact.join('; charset=') )
+    end
+
+    # the default content-type is "text/html"
+    def content_type
+      split_content_type[0]
+    end
+
+    def content_type= new_content_type
+      content1, charset1 = split_content_type
+      content2, charset2 = split_content_type( new_content_type )
+      
+      set_full_content_type( content2 || content1,
+                             charset2 || charset1 )
+    end
+    
+    def charset
+      split_content_type[1]
+    end
+
+    def charset= new_charset
+      set_full_content_type( content_type, new_charset )
+    end
+    
+    # Cookies require a name and a value.  You can also use these
+    # optional keyword arguments:
+    # <b>:path</b> => <i>string<i>:: path (need better description)
+    # <b>:domain</b> => <i>string</i>:: domain (need better description)
+    # <b>:expires</b> => <i>date</i>:: date this cookie should expire
+    # <b>:secure</b> => <i>true || false </i>:: whether this cookie should be
+    #                                           tagged as secure.
+    def set_cookie( name, value, options={} )
+      #self.cookie[name] = [ ] unless self.cookie.has_key? name
+      #self.cookie[name].push value
+
+      value = Array(value).collect{ |field|
+        Web::escape(field)
+      }.join("&")
+      
+      cookie_text = "#{ name }=#{ value }"
+      
+      
+      path = if (options[:path])
+               options[:path]
+             else
+               %r|^(.*/)|.match(env["script_name"])
+               ($1 or "")
+             end
+      
+      cookie_text += "; path=#{ path }"
+      
+      if (options[:domain])
+        cookie_text += "; domain=#{ options[:domain] }"
+      end
+      
+      if (options[:expires])
+        cookie_text += "; expires=#{ Web::rfc1123_date( options[:expires] ) }"
+      end
+      
+      if (options[:secure])
+        cookie_text += "; secure"
+      end
+      
+      add_header( "Set-Cookie", cookie_text )
+    end
+
+    # returns an array of cookie values that have been set.
+    # path / expires / etc. info is currently not returned, should
+    # be added in?
+    def get_cookie key
+      #get_header("Set-Cookie").collect{ |cookie|
+      #  /\A(#{ key })=([^;]*)/ =~ cookie
+      #  $2
+      #}.compact
+      self.cookie[key]
+    end
+
+    # returns a hash of all the cookie n/v pairs that have
+    # been set on the cgi
+    def cookies_sent
+      cookies = {}
+      get_header("Set-Cookie").each do |cookie|
+        /\A(.*?)=([^;]*)/ =~ cookie
+        cookies[$1] ||= [ ]
+        cookies[$1].push $2
+      end
+      cookies
+    end
+
+    # Aside from when :nph is set in the options, scripts running in IIS always
+    # use nph mode.  This code will probably be affected as cgi is re-organized
+    # to support multiple backends.
+    def nph?
+      @cgd.nph?
+    end
+    
+    ENV_KEYS = [ :path_info, :document_root, :script_name ]
+
+    ENV_KEYS.each{ |symbol|
+      define_method( symbol ) {
+        env[symbol.to_s]
+      }
+    }
+
+    #------------------------------
+    # implementation details, aka
+    # refactoring targets below
+    #------------------------------
+    def report_error( error )
+      self.status = 500 unless self.header_sent?
+      self.content_type = "text/html"
+      
+      Web::config::describe( :error_style => "Controls error reporting.  One of three values: :development, :production, or :custom" )
+      Web::config[:error_style] ||= :development
+      
+      case Web::config::error_style
+
+      when :development
+        
+        Web::print_message( error.class.to_s,
+                            error.rbw_html + error.rbw_backtrace_html )
+        self.report_error2stderr( error )
+
+      when :production
+        
+        Web::print_message( error.class.to_s, 
+                            error.rbw_html )
+        self.report_error2stderr( error )
+        
+      when :custom
+      
+        Web::config::error_handler.call( error )
+
+      else
+        
+        raise error
+      
+      end
+    end
+
+    def report_error2stderr( err )
+      unless Web::env['server_software'] =~ /Microsoft-IIS/
+        $stderr.binmode
+        $stderr.puts err.rbw_to_s
+      end
+    end
+
+
+
+    def Connection::create(options={})
+      if (options[:connection])
+        options[:connection]
+      else
+        case Connection::server_sniff
+        when :fcgi
+          require 'web/sapi/fastcgi'
+          Web::FastCGIConnection.new( options )
+        when :mod_ruby
+          Web::ModRubyConnection.new( options )
+        else
+          Connection.new(options)
+        end
+      end
+    end
+    
+    # try to include fastcgi
+    begin
+      require 'fcgi'
+    rescue LoadError
+      
+    end
+    
+    # returns one of these values:
+    # :cgi, :fastcgi, :mod_ruby, :webrick
+    def Connection::server_sniff
+      if( Object.const_defined?( "Apache" ) \
+          && Apache.const_defined?( "Request" ) \
+          && $stdin.kind_of?( Apache::Request ) )
+        :mod_ruby
+      elsif ( Object.const_defined?( "FCGI" ) \
+              && ! FCGI.is_cgi? )
+        :fcgi
+      else
+        :cgi
+      end
+    end
+
+        # This method counts on the attributes of a cgd: options, raw_post_data, env
+    # It will set @cookie, @get, @post, and @request
+    def parse_request
+      @cookie ||= CookieHash.new( env['http_cookie'] || env['cookie'] )
+      @get    ||= Connection::parse_query_string(env["query_string"])
+      @post   ||= if (multipart?)
+                    parse_multipart
+                  else
+                    raw_post_data.binmode
+                    query_string = raw_post_data.read(Integer(env['content_length'])) || ''
+                    @raw_post_data = StringIO.new(query_string)
+                    Connection::parse_query_string( query_string )
+                  end
+    end
+    
+    class CookieHash < Hash
+      def initialize( values )
+        super([])
+        update(values)
+      end
+
+      def update(values)
+        if values.kind_of? Hash
+          super(values)
+        elsif values
+          raw_cookie = values.to_s
+          raw_cookie.split(/; /).each do |pairs|
+            name, values = pairs.split('=',2)
+            name = Web::unescape(name)
+            values ||= ""
+            values = values.split('&').collect{|v| Web::unescape(v) }
+            if self.has_key?(name)
+              self[name].push(*values)
+            else
+              self[name] = values
+            end
+          end
+        end
+      end
+
+      def update_by_addcookie(line)
+        line.gsub!( /;.*$/, '' )
+        self.update(line)
+      end
+    end
+    
+    def cookie=(other)
+      raise ArgumentError.new unless other
+      @cookie = CookieHash.new(other)
+    end
+
+    # returns a hash with downcased keys of the env_in variable
+    def Connection::downcase_env( env_in )
+      env = CaseInsensitiveHash.new
+      env_in.each{ |k, v|
+        env[k.downcase] = v
+      }
+      env
+    end
+
+    # normalizes a params hash
+    def Connection::normalize( params )
+      params.each { |key, value|
+        unless value.kind_of? Array
+          params[key] = [value]
+        end
+      }
+      params.default = []
+      params
+    end
+
+    
+    # Parse a query_string into parameters
+    def Connection::parse_query_string(query)
+      query ||= ""
+      params = Hash.new([])
+      
+      query.split(/[&;]/n).each do |pairs|
+        key, value = pairs.split('=',2).collect{|v| Web::unescape(v) }
+        if params.has_key?(key)
+          params[key].push(value)
+        else
+          params[key] = [value]
+        end
+      end
+      
+      params
+    end
+    
+    # this method solely exists b/c of difficulties setting MOD_RUBY dynamically.
+    # so this method exists so I can test the effect separately
+    # from the (currently untestable) cause
+    def mod_ruby_query_string     #:nodoc:
+      Apache::request.args
+    end
+    
+    def multipart?
+      ("POST" == env['request_method']) &&
+            (/multipart\/form-data/.match(env['content_type']))
+    end
+    
+    # parse multipart/form-data
+    def parse_multipart
+      %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n.match(env['content_type'])
+      boundary = $1.dup
+      read_multipart(boundary, Integer(env['content_length']))
+    end
+    
+    EOL="\r\n"
+    
+    Web::config::describe( :multipart_progress_hook => "Lambda to enable progress reports for uploads.  Added for rails" )
+                           
+    def progress_hook
+      Web::config::multipart_progress_hook
+    end
+    def call_progress_hook(full, read)
+      if (progress_hook)
+        progress_hook.call( full,
+                            read )
+      end
+    end
+    
+    def read_multipart(boundary, content_length)
+      require 'tempfile'
+
+      params = Hash.new([])
+      boundary = "--" + boundary
+      buf = ""
+      cached_raw_post_data = Tempfile.new("Web")
+      bufsize = 10 * 1024
+      
+      # start multipart/form-data
+      raw_post_data.binmode
+      boundary_size = boundary.size + EOL.size
+      content_length -= boundary_size
+      status = raw_post_data.read(boundary_size)
+      if nil == status
+        raise EOFError, "no content body"
+      end
+      cached_raw_post_data << status
+      
+      # ok... so what the hell does this do?
+      # I promise never to denigrate the accomplishments
+      # of my predecessors again :-)
+      #    ~ pat
+      full_content_length = content_length
+      until -1 == content_length
+        call_progress_hook( full_content_length,
+                            full_content_length - content_length )
+        head = nil
+        body = Tempfile.new("Web")
+        body.binmode
+        
+        # until we have:
+        #   * a header
+        #   * and a buffer that has a boundary
+        # so far, make sense to me.
+        until head and /#{boundary}(?:#{EOL}|--)/n.match(buf)
+        
+          # if we have a header....
+          if head
+            # !??!??!?!?!
+            trim_size = (EOL + boundary + EOL).size
+            if trim_size < buf.size
+              body.write buf[0 ... (buf.size - trim_size)]
+              buf[0 ... (buf.size - trim_size)] = ""
+            end
+          
+          # If we have a double space (the smell of a header...)
+          elsif /#{EOL}#{EOL}/n.match(buf)
+            # extract the header, and erase it from the buffer
+            buf = buf.sub(/\A((?:.|\n)*?#{EOL})#{EOL}/n) do
+              head = $1.dup
+              ""
+            end
+            next
+          end
+          
+          # read a chunk from the raw_post_data
+          c = if bufsize < content_length
+                raw_post_data.read(bufsize) or ''
+              else
+                raw_post_data.read(content_length) or ''
+              end
+          # add it to the raw_post_data, reduce our countdown
+          cached_raw_post_data << c
+          buf.concat c
+          ### debugging for making multipart_asserts work ~ pat
+          #$defout.puts [bufsize, content_length, c.size].inspect, raw_post_data.read(bufsize).inspect
+          content_length -= c.size
+        end
+        
+        /Content-Disposition:.* filename="?([^\";]*)"?/ni.match(head)
+        filename = ($1 or "").dup
+        if /Mac/ni.match(env['http_user_agent']) and
+            /Mozilla/ni.match(env['http_user_agent']) and
+            (not /MSIE/ni.match(env['http_user_agent']))
+          filename = Web::unescape(filename)
+        end
+        
+        /Content-Type: (.*)/ni.match(head)
+        content_type = ($1 or "").strip
+        
+        # is this the part that is eating too much?
+        #buf = buf.sub(/\A(.*?)(?:#{EOL})?#{boundary}(#{EOL}|--)/mn) do
+        buf = buf.sub(/\A((?:.|\n)*?)(?:[\r\n]{1,2})?#{boundary}([\r\n]{1,2}|--)/n) do
+          body.print $1
+          if "--" == $2
+            content_length = -1
+          end
+          ""
+        end
+        
+        body.rewind
+
+     
+        if (content_type.empty?)
+          upload = body.read
+        else
+          upload = Web::Upload.new( body, content_type, filename )
+        end
+
+        /Content-Disposition:.* name="?([^\";]*)"?/ni.match(head)
+        name = $1.dup
+
+
+        body.rewind
+
+        if params.has_key?(name)
+          params[name].push(upload)
+        else
+          params[name] = [upload]
+        end
+        
+      end
+
+      call_progress_hook( full_content_length,
+                          full_content_length - content_length - 1)
+      
+      @raw_post_data = cached_raw_post_data
+      params
+    end # read_multipart
+    
+    # == Purpose
+    #
+    # this hash is has case insensitive keys.  Might be somewhat
+    # incomplete
+    class CaseInsensitiveHash < Hash #:nodoc:
+      def [](key)
+        super( key.to_s.downcase )
+      end
+      
+      def []= (key, value)
+        super( key.to_s.downcase, value )
+      end
+      
+      def has_key? (key)
+        super( key.to_s.downcase )
+      end
+    end
+    
+  end
+end