ruby-web 1.1.1

data/lib/web/shim/rails.rb

@@ -0,0 +1,175 @@
+#require 'action_controller/cgi_ext/cgi_ext'
+#require 'action_controller/cgi_ext/cookie_performance_fix'
+#require 'action_controller/cgi_ext/raw_post_data_fix'
+#require 'action_controller/session/drb_store'
+#require 'action_controller/session/mem_cache_store'
+#if Object.const_defined?(:ActiveRecord)
+#  require 'action_controller/session/active_record_store'
+#end
+
+module ActionController #:nodoc:
+  class Base
+    # Derived from CGI controller.
+    # Process a request extracted from an CGI object and return a response. Pass false as <tt>session_options</tt> to disable
+    # sessions (large performance increase if sessions are not needed). The <tt>session_options</tt> are the same as for CGI::Session:
+    #
+    # * <tt>:database_manager</tt> - standard options are CGI::Session::FileStore, CGI::Session::MemoryStore, and CGI::Session::PStore
+    #   (default). Additionally, there is CGI::Session::DRbStore and CGI::Session::ActiveRecordStore. Read more about these in 
+    #   lib/action_controller/session.
+    # * <tt>:session_key</tt> - the parameter name used for the session id. Defaults to '_session_id'.
+    # * <tt>:session_id</tt> - the session id to use.  If not provided, then it is retrieved from the +session_key+ parameter
+    #   of the request, or automatically generated for a new session.
+    # * <tt>:new_session</tt> - if true, force creation of a new session.  If not set, a new session is only created if none currently
+    #   exists.  If false, a new session is never created, and if none currently exists and the +session_id+ option is not set, 
+    #   an ArgumentError is raised.
+    # * <tt>:session_expires</tt> - the time the current session expires, as a +Time+ object.  If not set, the session will continue
+    #   indefinitely.
+    # * <tt>:session_domain</tt> -  the hostname domain for which this session is valid. If not set, defaults to the hostname of the
+    #   server.
+    # * <tt>:session_secure</tt> - if +true+, this session will only work over HTTPS.
+    # * <tt>:session_path</tt> - the path for which this session applies.  Defaults to the directory of the CGI script.
+    def self.process_cgi(cgi = CGI.new, session_options = {}) 
+      new.process_cgi(cgi, session_options)
+    end
+  
+    def process_cgi(cgi, session_options = {}) #:nodoc:
+      process(CgiRequest.new(cgi, session_options), CgiResponse.new(cgi)).out
+    end
+  end
+
+  class CgiRequest < AbstractRequest #:nodoc:
+    attr_accessor :cgi
+
+    DEFAULT_SESSION_OPTIONS = {
+      :database_manager => CGI::Session::PStore,
+      :prefix => "ruby_sess.",
+      :session_path => "/"
+    } unless const_defined?(:DEFAULT_SESSION_OPTIONS)
+
+    def initialize(cgi, session_options = {})
+      @cgi = cgi
+      @session_options = session_options
+      super()
+    end
+
+    def query_string
+      return @cgi.query_string unless @cgi.query_string.nil? || @cgi.query_string.empty?
+      unless env['REQUEST_URI'].nil?
+        parts = env['REQUEST_URI'].split('?')
+      else
+        return env['QUERY_STRING'] || ''
+      end      
+      parts.shift
+      return parts.join('?')
+    end
+
+    def query_parameters
+      qs = self.query_string
+      qs.empty? ? {} : CGIMethods.parse_query_parameters(query_string)
+    end
+
+    def request_parameters
+      if formatted_post?
+        CGIMethods.parse_formatted_request_parameters(post_format, env['RAW_POST_DATA'])
+      else
+        CGIMethods.parse_request_parameters(@cgi.params)
+      end
+    end
+    
+    def env
+      @cgi.send(:env_table)
+    end
+
+    def cookies
+      @cgi.cookies.freeze
+    end
+
+    def host
+      env["HTTP_X_FORWARDED_HOST"] || @cgi.host.to_s.split(":").first
+    end
+    
+    def session
+      return @session unless @session.nil?
+
+      begin
+        @session = (@session_options == false ? {} : CGI::Session.new(@cgi, session_options_with_string_keys))
+        @session["__valid_session"]
+        return @session
+      rescue ArgumentError => e
+        if e.message =~ %r{undefined class/module (\w+)}
+          begin
+            Module.const_missing($1)
+          rescue LoadError, NameError => e
+            raise(
+              ActionController::SessionRestoreError, 
+              "Session contained objects where the class definition wasn't available. " +
+              "Remember to require classes for all objects kept in the session. " +
+              "(Original exception: #{e.message} [#{e.class}])"
+            )
+          end
+        
+          retry
+        else
+          raise
+        end
+      end
+    end
+    
+    def reset_session
+      @session.delete
+      @session = (@session_options == false ? {} : new_session)
+    end
+
+    def method_missing(method_id, *arguments)
+      @cgi.send(method_id, *arguments) rescue super
+    end
+
+    private
+      def new_session
+        CGI::Session.new(@cgi, session_options_with_string_keys.merge("new_session" => true))
+      end
+      
+      def session_options_with_string_keys
+        DEFAULT_SESSION_OPTIONS.merge(@session_options).inject({}) { |options, pair| options[pair.first.to_s] = pair.last; options }
+      end
+  end
+
+  class CgiResponse < AbstractResponse #:nodoc:
+    def initialize(cgi)
+      @cgi = cgi
+      super()
+    end
+
+    def out(output = $stdout)
+      convert_content_type!(@headers)
+      output.binmode      if output.respond_to?(:binmode)
+      output.sync = false if output.respond_to?(:sync=)
+      
+      begin
+        output.write(@cgi.header(@headers))
+
+        if @cgi.send(:env_table)['REQUEST_METHOD'] == 'HEAD'
+          return
+        elsif @body.respond_to?(:call)
+          @body.call(self)
+        else
+          output.write(@body)
+        end
+
+        output.flush if output.respond_to?(:flush)
+      rescue Errno::EPIPE => e
+        # lost connection to the FCGI process -- ignore the output, then
+      end
+    end
+
+    private
+      def convert_content_type!(headers)
+        %w( Content-Type Content-type content-type ).each do |ct|
+          if headers[ct]
+            headers["type"] = headers[ct]
+            headers.delete(ct)
+          end
+        end
+      end
+  end
+end

data/lib/web/stringio.rb

@@ -0,0 +1,78 @@
+module Web 
+    # WritableIO uses << operator to add io style write, print, and puts methods
+    module WritableIO # :nodoc:
+	# writes object to output stream
+	def write object
+	    self << object
+	end
+
+	# writes objects to the output stream
+	def print( *objects )
+	    if (objects.empty?)
+		self << $_
+	    else
+		self << objects.collect{ |s| s.to_s }.join("")
+	    end
+	    if $\ then self << $\ end
+        end
+	
+	# writes multiple lines to the output stream
+	def puts( *objects )
+	    objects.flatten!
+	    self  << objects.collect{ |s|
+		s.to_s 
+	    }.collect{ |s|
+		unless ( /(\r|\n)\z/ =~ s )
+		    s + $/
+		else
+		    s
+		end
+	    }.join("")
+	end
+    end
+end
+
+begin
+    require('stringio') 
+rescue LoadError    
+  module Web
+    class StringIO  # :nodoc:
+      def initialize
+        @___content___ = ""
+      end
+      
+      def read
+        @___content___
+      end
+      
+      def clear
+        @___content___ = ""
+      end
+      
+      def string
+        @___content___
+      end
+      
+      def puts(*args)
+        @___content___ << args.join("\n") << "\n"
+      end
+      
+      def << var
+        @___content___ << var.to_s
+      end
+      
+      def write var
+        @___content___ << var.to_s
+      end
+      
+      def print var
+        @___content___ << var.to_s
+      end
+    end
+  end
+  
+  unless Kernel.const_defined? "StringIO"
+    StringIO = Web::StringIO.clone
+  end
+end
+

data/lib/web/strscanparser.rb

@@ -0,0 +1,24 @@
+class StrScanParserR # :nodoc:
+    def initialize scanner
+	@scanner = scanner
+    end
+    
+    def match regex, &block
+	if s = @scanner.scan(regex)
+	 #   $stderr.puts "got: #{s}"
+	    yield @scanner if block
+	    s
+	else
+	  #  $stderr.puts "tried #{regex.source} on: #{@scanner.rest}"
+	    nil
+	end
+    end
+
+    def rest?
+	@scanner.rest?
+    end
+
+    def rest
+	@scanner.rest
+    end
+end

data/lib/web/tagparser.rb

@@ -0,0 +1,96 @@
+Struct.new("Tag",:name,:attributes)
+Tag = Struct::Tag
+
+class StrScanParser < StrScanParserR #:nodoc:
+
+    TAG_START = /<narf:/
+    TAG_END = />/
+    TAG_CLOSE_START = /<\/narf:/
+    TAG_NAME = /(\w+)/
+    WHITESPACE = /\s*/
+    QUOTE = /"/
+    QUOTED_ATTRIBUTE_VALUE = /([^"?]+)/
+    UNQUOTED_ATTRIBUTE_VALUE = /([\w.\/\$?]+)/
+    EQUALS = /=/
+    ATTRIBUTE_NAME = /(\w+)/
+    
+    def match_value 
+	if @scanner.scan(QUOTE)
+	    if @scanner.scan(QUOTED_ATTRIBUTE_VALUE)
+		yield @scanner[1]
+		@scanner.scan(QUOTE) || raise(MissingQuoteException.new)
+	    end
+	elsif @scanner.scan(UNQUOTED_ATTRIBUTE_VALUE)
+	    yield @scanner[1]
+	end
+    end
+    
+    def match_attribute
+	if @scanner.scan(ATTRIBUTE_NAME)
+	    name = @scanner[1]
+	    if @scanner.scan(EQUALS)
+		match_value do |value|
+		    yield({ name => value })
+		end || raise(MissingAttributeException.new)
+	    else
+		yield({ name => nil })
+	    end
+	end 
+    end
+    
+    def match_tag
+	if @scanner.scan(TAG_START)
+	    name = ""
+	    nvs = {}
+	    if @scanner.scan(TAG_NAME)
+		name = @scanner[1]
+		while true
+		    @scanner.scan(WHITESPACE)
+		    match_attribute do |nv|
+			nvs.update(nv)
+		    end || if @scanner.scan(TAG_END)
+			       yield Tag.new(name,nvs)
+			       return true
+			   else 
+			       raise(TagNotClosedException.new)
+			   end
+		end
+	    else
+		raise(TagNotNamedException.new)
+	    end
+	end
+    end
+
+    def match_close_tag
+	if @scanner.scan(TAG_CLOSE_START)
+          tag = nil
+          if @scanner.scan(TAG_NAME) 
+            tag = @scanner[1]
+          end # TODO raise missing name exception
+          @scanner.scan(TAG_END) # TODO raise missing end tag exception
+          yield tag if tag
+	end
+    end
+    
+    def match_identifier
+	if @scanner.scan(/\{\$([\w.\?]*?)\}/)
+            yield @scanner[1]
+        end
+    end
+end
+
+class MissingAttributeException < Exception # :nodoc:
+
+end
+
+class TagNotClosedException < Exception # :nodoc:
+    
+end
+
+class TagNotNamedException < Exception # :nodoc:
+    
+end
+
+class MissingQuoteException < Exception # :nodoc:
+    
+end

data/lib/web/testing.rb

@@ -0,0 +1,666 @@
+require 'web'
+
+require 'web/htmltools/tree'
+module HTMLTree # :nodoc: all
+  module TreeElement
+    def get_elements aname, elements=[]
+	    children.each { |element|
+        if element.tag == aname
+          elements.push element
+        else
+          element.get_elements aname, elements
+        end
+	    }
+	    elements
+    end
+  end
+end
+
+require 'web/assertinclude'
+require 'web/strscanparser'
+require 'web/tagparser'
+require 'web/formreader.rb'
+
+require 'test/unit/assertions'
+
+module Web
+  def Web::setup( options = {} )
+    options[:out] ||= ''
+    Web::config[:error_style] = :testing
+    Web.connection = Web::Connection.new(options)
+  end
+
+  def Web::teardown
+    Web::config[:error_style] = :default
+  end
+  
+  class Connection
+    include Test::Unit::Assertions
+    
+    # for testing: raises Test::Unit exception if content
+    # is not set to the provided string.
+    def assert_content expected, message=""
+      assert_equal( expected, get_content, message );
+    end
+    
+    def get_formreader #:nodoc:
+      return @form_fields_cache ||= FormReader.new( get_content )
+    end
+    
+    def get_form( name ) #:nodoc:
+      get_formreader[name]
+    end
+    
+    def get_form_fields(name) #:nodoc:
+      get_formreader.get_fields(name)
+    end
+    
+    def get_form_value formname, name #:nodoc:
+      form = get_form_fields(formname)
+      if form == nil
+        raise Web::Error.new("Form '#{formname}' does not exist") 
+      end
+      
+      value = form[name]
+      value
+    end
+    
+    # assert output content contains a form
+    # that includes the given hash of values.  See Web::Testing
+    def assert_form_includes formname, vars
+      assert_includes vars, get_form_fields(formname)
+    end
+
+    # Raises Test::Unit::AssertionFailedError if the header
+    # has not been set to the provided value(s)
+    def assert_header( name, values, message="" )
+      assert_equal( [values].flatten, get_header(name), message )
+    end
+
+    # Throws Test::Unit::AssertionFailedException if
+    # cookie values are not present.
+    def assert_cookie( name, values, message="" )
+      assert_equal( [ values ].flatten, [ cookies_sent[name] ].flatten, message )
+    end
+
+        # Check that a particluar template was used 
+    def assert_template_used expected, message =""
+      _wrap_assertion {
+        flunk("No template used") if @templates == nil
+        unless @templates.include? expected
+          msg = "expected template:<#{expected}> but not one of:<#{@templates.inspect}>"
+          flunk(msg)
+        end
+      }
+    end
+    
+    # Check that a particluar template was not used 
+    def assert_template_not_used expected, message =""
+      _wrap_assertion {
+        if (@templates.kind_of?(Array) && @templates.include?(expected) )
+          msg = "template:<#{expected}> not supposed to be used in:<#{@templates.inspect}>"
+          flunk(msg)
+        end
+      }
+    end
+    
+    # Check that these values were included in the output
+    def assert_local_includes expected
+      assert_includes expected, @local
+    end
+
+    def assert_vars_equals
+      raise Exception.new("Not yet implemented")
+    end
+
+    
+  end
+  
+  # == Purpose
+  # The testing module facilitates the testing of Web applications
+  # without the overhead of a web server to run.
+  #
+  # Given these files:
+  #
+  #    script.rb
+  #    test.rb
+  #
+  # where script.rb is:
+  #
+  #    #!/usr/bin/ruby
+  #    require 'web'
+  #
+  #    Web::process { 
+  #      Web.write "param is #{Web["param"]}"
+  #    }
+  #
+  # and test.rb is:
+  #    
+  #    require 'web'
+  #    require 'test/unit'
+  #
+  #    class MyAppTest < Test::Unit::TestCase
+  #        include Web::Testing
+  #
+  #        def test_prints_content
+  #            do_request "script.rb", "param" => "THIS!"
+  #            assert_content "param is THIS!"
+  #        end
+  #    end
+  #
+  # Do this to run tests:
+  #
+  #     ruby test.rb
+  #
+  # If you have a more complicated app, where the tests live in
+  # a different place than your scripts, you can use:
+  #
+  #    Web::docroot = path
+  #
+  # To tell narf where to find your cgi scripts.
+  #
+  #
+  # === Testing with Templates
+  # 
+  # Using Narflates you can test functionality without having to
+  # do lengthly string comparisons.  For example, create the following
+  # file in 'mytemplate.html'
+  #
+  #     <html>
+  #       <body>
+  #         {$myvar}
+  #       </body>
+  #     </html>
+  # 
+  # Create a 'script.rb' as follows:
+  #
+  #     #!/usr/bin/narf
+  #     require 'web'
+  #
+  #     Web::process{
+  #       Web.print_template "mytemplate.html", { "myvar" => "Hello World" }
+  #     }
+  #
+  # Now, we can check that the right values got displayed without
+  # needing to check that the template is correct as a side effect.
+  # Save this into 'test.rb' and run it:
+  #
+  #     require 'web'
+  #
+  #     class MyAppTest < Test::Unit::TestCase
+  #         include Web::Testing          # adds the modules
+  #
+  #         def test_prints_content
+  #             do_request "script.rb"
+  #             assert_vars_includes "myvar" => "Hello World"
+  # 	      end
+  #     end
+  #
+  # === Testing Forms
+  #
+  # The following example demonstrates testing a simple HTML form.
+  # Creating mytemplate.html as:
+  #
+  #
+  #     <html>
+  #       <body>
+  #         <form name="myform">
+  #           <input type="text" name="foo">
+  #           <input type="submit" name="submit" value="Submit">
+  #       </body>
+  #     </html>
+  #
+  # To print this form and handle a submit save this as 'script.rb':
+  #
+  #     #!/usr/bin/narf
+  #     
+  #     require 'web'
+  #     
+  #     Web::process {
+  #       if Web["submit"]   # check to see whether a form was
+  #           Web.puts "Form Submitted with value '#{Web["foo"]}'"  
+  #       else
+  #           Web.print_template "mytemplate.html"
+  #       end
+  #     }
+  #
+  # Use this 'test.rb' to test it:
+  #
+  #     class MyAppTest < Test::Unit::TestCase
+  #         include Web::Testing          # adds the modules
+  #
+  #         def test_prints_content
+  # 	          do_request "script.rb"
+  #             do_submit "myform", "foo" => "bar"
+  #             assert_content "Form Submitted with value '#{Web["foo"]}'"
+  # 	      end
+  #     end
+  #
+  #
+  # === Test <input type="text|password|hidden"> and <textarea>
+  #
+  # html:
+  #
+  #     <form name='aForm'>
+  #     <input name="bare">
+  #     <input name="named"   type="text"     value="foo">
+  #     <input name="pass"    type="password" value="secret">
+  #     <input name="obscure" type="hidden"   value="discrete">
+  #     <textarea name="big_text">
+  #     big paragraph here
+  #     </textarea>
+  #     </form>
+  #
+  # assert:
+  #
+  #     assert_form_includes( 'aForm', "bare"     => "",
+  #                                    "named"    => "foo",
+  #                                    "pass"     => "secret",
+  #                                    "obscure"  => "discrete",
+  #                                    "big_text" => "big paragraph here" )
+  #
+  # submit:
+  #
+  #     do_submit( 'aForm', "bare"     => "empty",
+  #                         "named"    => "bare",
+  #                         "pass"     => "shhhhh",
+  #                         "obscure"  => "secretive",
+  #                         "big_text" => "windbag" )
+  #
+  # === Test <input type="file">
+  #
+  # html:
+  #
+  #     <form name='aForm' enctype='multipart/form-data'>
+  #     <input name="upload" type="file">
+  #     </form>
+  #
+  # assert:
+  #
+  #     assert_form_includes( 'aForm', "upload" => "" )
+  #
+  # submit:
+  #
+  #     do_submit( 'aForm', "upload" => Web::Upload.new(
+  #                                       File.new( "testfile" ),
+  #                                       "content-type",
+  #                                       "original-filename" ) )
+  #
+  # === Test <select> and <input type="radio">
+  #
+  # 
+  #
+  # === Test <select multiple> and <input type="checkbox">
+  #
+  #
+  # === Bugs: Unsupported behaviour
+  #
+  #  The following situations will have unknown results:
+  #
+  #  * Combining different types of elements into one field;
+  #    i.e. <input name="field" type="text"> and <select name="field">
+  #  * Comparing <input name="page.name"> and <input name="page.content">
+  #    with assert_vars_include("page" => { "name" => ..., "content" => ... } )
+  #
+  module Testing
+    class FormNotFoundException < Exception #:nodoc:
+    end
+
+    class FieldNotFoundException < Exception #:nodoc:
+    end
+
+    class MustSetDocrootForAbsolutePathException < Exception #:nodoc:
+    end
+
+    def write_file( path, content )
+      filename = File.join( Web::docroot, path )
+      filedir  = File.dirname(filename)
+      unless File.exists? filedir
+        require 'fileutils'
+        FileUtils::mkdir_p(filedir, :verbose => false)
+      end
+      
+      File.open( filename, "w" ) do |f|
+        f.write content
+      end
+    end
+
+    def select( *args )
+      hash = {}
+      
+      if (args.length == 1 and args[0].kind_of? Hash)
+        hash = args[0]
+      else
+        args.each { |e|
+          hash[e] = true
+        }
+      end
+      
+      hash
+    end
+    
+    @@test_session = nil
+
+    # Reset the session used by the test framework. Call prior to all tests
+    # that rely on the session being clean
+    def reset_session
+      @@test_session = nil
+    end
+    
+    # Run a request, parameters are the name value pairs that would be
+    # passed in the query string. The webpath is a document root relative 
+    # path to a ruby script.
+    def do_request(webpath, parameters={}) 
+      options = {}
+      @@test_session ||= {}
+      options[:session] = @@test_session
+      options[:env] = parameters[:env]
+      options[:request] = parameters
+      options[:document_root] = Web::docroot
+      options[:out] = StringIO.new
+      script_path, script_name, path_info = get_script_part(webpath)
+      
+      options[:path_info] = path_info
+      options[:script_name] = script_name
+      load_request( options, script_path, webpath )
+    end
+    
+    def load_request( options, script_path, webpath ) #:nodoc:
+      options[:webpath] = webpath
+      ### re-throw errors
+      Web::config[:error_style] = :custom
+      Web::config[:error_handler] = lambda do |error|
+        raise error
+      end
+      
+      # out with the old....
+      #Web::connection.close
+      Web::connection = nil
+      error = nil
+      Web::open( options ) do
+        Web::load( script_path )
+      end
+      
+      if Web.status == "302"
+	      Web.location =~ /(.*)\?(.*)/
+        target = $1
+        params = Connection::parse_query_string($2)
+        
+        unless (target =~ /^\//)
+          webpath =~ /(.*)#{File.basename(script_path)}/
+          target = $1 + target
+	      end
+        do_request( target, params )
+      end
+    end
+    
+    # Submit the form 'formname' with the formfields described in newvalues
+    def do_submit( formname, newvalues={} )
+      form = Web.get_form(formname)
+      
+      if form == nil
+        #if Web.get_form_fields[formname] == nil
+	raise FormNotFoundException.new("Form '#{formname}' does not exist") 
+      end
+      
+      #MultiHashTree::flatten(newvalues).keys.each do |key|
+	#unless( Web.get_form_fields[formname].valid_key?(key) )
+	 # raise FieldNotFoundException.new( "#{ key } is not present in form" )
+	#end
+      #end
+
+      webpath = nil
+      
+      #Web.get_html_tree.get_elements("form").each { |form|
+      #  if (form.attribute("name") == formname)
+      #    webpath = form.attribute("action")
+      #  end
+      #}
+      webpath = form.action
+
+      unless (webpath)
+        webpath = Web.options[:webpath]
+      end
+
+      script_path, script_name, path_info = get_script_part(webpath)
+
+      old_connection = Web.connection
+
+      options = {}
+      @@test_session ||= {}
+      options[:session] = @@test_session
+      options[:out] = StringIO.new
+      ### patrick
+      options[:request] = form.merge_fields( newvalues )
+      #options[:request] = Web.get_form_fields[formname].params(MultiHashTree::flatten(newvalues))
+      options[:document_root] = old_connection.document_root
+
+      options[:path_info] = path_info     #old_connection.path_info
+      options[:script_name] = script_name #old_connection.script_name
+
+      load_request( options, script_path, webpath )
+    end
+
+    # Assert that a give template was displayed
+    def assert_template_used filename, msg=""
+      Web.assert_template_used filename, msg
+    end
+
+    # Assert that a give template was not displayed
+    def assert_template_not_used filename, msg=""
+      Web.assert_template_not_used filename, msg
+    end
+
+    # Assert that the values passed in to expected were set on the template
+    def assert_vars_includes expected
+      Web.assert_vars_includes expected
+    end
+    
+    # Assert that the form displayed contains particular values
+    def assert_form_includes formname, expected
+      Web::assert_form_includes formname, expected
+    end
+    
+    # Assert that the entire content displayed is equal to expected
+    def assert_content expected, msg=""
+      Web.assert_content expected, msg
+    end
+    
+    # Assert that the header key has the value 'value'
+    def assert_header key, value, msg=""
+      Web.assert_header key, value, msg
+    end
+
+    # Assert that the cookie key, has the cookie value
+    def assert_cookie key, value, msg=""
+      Web.assert_cookie key, value, msg
+    end
+    
+    # Assert that a form field has exactly the given options
+    # can't assert order, though
+    def assert_options( formname, expected={})
+      options = Web.get_formreader.get_options(formname)
+      expected.each{ |k,v|
+        assert_equal( v.sort, options[k].sort )
+      }
+    end
+
+    def remove_trailing_slashes(filename)  #:nodoc:
+      /(.*?)\/?$/.match(filename)[1]
+    end
+
+    def get_script_part(webpath)  #:nodoc:
+      # two cases:
+      #   absolute webpath (requires Web::docroot to be correct)
+      #   relative webpath (doesn't require Web::docroot to be correct)
+      if ( webpath =~ /^\// )
+        prefix = Web::docroot
+        raise MustSetDocrootForAbsolutePathException unless prefix
+        path = "/"
+      else
+        prefix = ""
+        path = ""
+      end
+
+      new_script_path = ""
+      webpath.split("/").each do |file|
+	file =~ /^([a-zA-Z]{1,1}:)$/
+
+        if (path.empty?)
+          newpath = file
+        else
+          newpath = File.join( path , file ).gsub("//","/") 
+        end
+
+        new_script_path = ""
+        if (prefix.empty?)
+          new_script_path = newpath
+        else
+          new_script_path = File.join( prefix, newpath ).gsub("//","/") 
+        end
+        
+        if (File.file?(new_script_path))
+	  return new_script_path, "/" + File.basename( new_script_path ), webpath[newpath.length...webpath.length]
+	end 
+	
+	path = newpath
+      end
+
+      if (!File.exists?(new_script_path) && prefix.empty?)
+        return get_script_part( "/" + webpath )
+      end
+
+      return new_script_path, "/" + File.basename( new_script_path ), ""
+    end
+
+    class SelectHash < Hash #:nodoc:
+      def == other
+        if (other.kind_of? Hash)
+          super(other)
+        elsif (other.class == TrueClass)
+          result = true
+          self.each{ |k, v|
+            result = false unless v
+          }
+          result
+        elsif (other.class == FalseClass)
+          result = true
+          self.each{ |k,v|
+            result = false if v
+          }
+          result
+        else
+          ### this is wrong
+          other.to_s == self.default.join(",")
+        end
+      end
+
+      def field_value
+        values = [ ]
+        self.each{ |k,v|
+          values.push k if v
+        }
+        values.join(",")
+      end
+
+    end
+
+    # could I get an explanation of this?
+    # just for me? please?
+    # not to long... probably not longer than this comment here.
+    class MultiHashTree # :nodoc:
+      attr_reader :fields, :unmodified_fields
+      
+      def initialize fields = {}
+        @fields = {}
+        @unmodified_fields = {}
+        fields.each do |k,value_array|
+          value_array.each{ |v|
+            push_field k, v
+          }
+        end
+      end
+      
+      def valid_key? (aKey)
+        unmodified_fields.has_key?(aKey) || fields.has_key?(aKey)
+      end
+      
+      def push_impl hash, name, value
+        if name =~ Web::Connection::MULTIPLE_KEY && !value.kind_of?(Web::Testing::SelectHash)
+          hash[name] ||= []
+          hash[name].push  value
+        elsif m = /^(\w+(\[\])?)\.(.+)/.match(name)
+          hash[m[1]] ||= {}
+          push_impl(hash[m[1]], m[3], value)
+        elsif m = /^(\w+)\[(\d+)\].(.+)/.match(name)
+          hash[m[1]] ||= []
+          hash[m[1]][m[2].to_i] ||= {}
+          push_impl hash[m[1]][m[2].to_i], m[3], value
+        else
+          hash[name] ||= []
+          hash[name].push(value)
+        end
+      end
+
+      def push_field name, value
+        @unmodified_fields[name] ||= []
+        @unmodified_fields[name].push value
+        push_impl @fields, name, value
+      end
+      
+      def params values
+        retval = @unmodified_fields.clone
+        values.each do |key,value|
+          if value.kind_of? SelectHash
+            selected_options = []
+            value.each{ |k,v|
+              selected_options.push k if v
+            }
+            
+            if m = Web::Connection::MULTIPLE_KEY.match(key)
+              retval[key] ||= []
+              retval[key] = (retval[key] + selected_options).uniq
+            else
+              retval[key] = selected_options.join(",")
+            end
+            
+          else
+            if m = Web::Connection::MULTIPLE_KEY.match(key)
+              retval[key] ||= []
+              retval[key] << value
+            else
+              retval[key] = value
+            end
+          end
+        end
+        retval
+      end
+      
+      def MultiHashTree.flatten node, newhash = {} , nameroot = "" # :nodoc:
+        if node.kind_of? Hash
+          node.each do |k,v|
+            if nameroot == ""
+              varname = k
+            else
+              varname = "#{nameroot}.#{k}" 
+            end
+            flatten( v, newhash, varname )
+          end
+        elsif node.kind_of? Array
+          unless node.find { |i| !i.kind_of? String }
+            newhash[nameroot] = node
+          else
+            node.each_with_index do |v,i|
+              flatten( v, newhash, "#{nameroot}[#{i}]" )
+            end
+          end
+        else
+          newhash[ nameroot ]=node
+        end
+        newhash
+      end
+      
+    end
+
+  end
+end