rails 1.0.0 → 7.0.0

data/lib/tasks/databases.rake

@@ -1,158 +0,0 @@
-desc "Migrate the database according to the migrate scripts in db/migrate (only supported on PG/MySQL). A specific version can be targetted with VERSION=x"
-task :migrate => :environment do
-  ActiveRecord::Migrator.migrate("db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
-  Rake::Task[:db_schema_dump].invoke if ActiveRecord::Base.schema_format == :ruby
-end
-
-desc "Load fixtures into the current environment's database"
-task :load_fixtures => :environment do
-  require 'active_record/fixtures'
-  ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)
-  Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.{yml,csv}')).each do |fixture_file|
-    Fixtures.create_fixtures('test/fixtures', File.basename(fixture_file, '.*'))
-  end
-end
-
-desc "Create a db/schema.rb file that can be portably used against any DB supported by AR."
-task :db_schema_dump => :environment do
-  require 'active_record/schema_dumper'
-  File.open(ENV['SCHEMA'] || "db/schema.rb", "w") do |file|
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
-  end
-end
-
-desc "Import a schema.rb file into the database."
-task :db_schema_import => :environment do
-  file = ENV['SCHEMA'] || "db/schema.rb"
-  load file
-end
-
-desc "Recreate the test database from the current environment's database schema."
-task :clone_schema_to_test => :db_schema_dump do
-  ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
-  Rake::Task[:db_schema_import].invoke
-end
-
-desc "Dump the database structure to a SQL file"
-task :db_structure_dump => :environment do
-  abcs = ActiveRecord::Base.configurations
-  case abcs[RAILS_ENV]["adapter"] 
-    when "mysql", "oci"
-      ActiveRecord::Base.establish_connection(abcs[RAILS_ENV])
-      File.open("db/#{RAILS_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
-    when "postgresql"
-      ENV['PGHOST']     = abcs[RAILS_ENV]["host"] if abcs[RAILS_ENV]["host"]
-      ENV['PGPORT']     = abcs[RAILS_ENV]["port"].to_s if abcs[RAILS_ENV]["port"]
-      ENV['PGPASSWORD'] = abcs[RAILS_ENV]["password"].to_s if abcs[RAILS_ENV]["password"]
-      search_path = abcs[RAILS_ENV]["schema_search_path"]
-      search_path = "--schema=#{search_path}" if search_path
-      `pg_dump -U "#{abcs[RAILS_ENV]["username"]}" -s -x -O -f db/#{RAILS_ENV}_structure.sql #{search_path} #{abcs[RAILS_ENV]["database"]}`
-    when "sqlite", "sqlite3"
-      dbfile = abcs[RAILS_ENV]["database"] || abcs[RAILS_ENV]["dbfile"]
-      `#{abcs[RAILS_ENV]["adapter"]} #{dbfile} .schema > db/#{RAILS_ENV}_structure.sql`
-    when "sqlserver"
-      `scptxfr /s #{abcs[RAILS_ENV]["host"]} /d #{abcs[RAILS_ENV]["database"]} /I /f db\\#{RAILS_ENV}_structure.sql /q /A /r`
-      `scptxfr /s #{abcs[RAILS_ENV]["host"]} /d #{abcs[RAILS_ENV]["database"]} /I /F db\ /q /A /r`
-    else 
-      raise "Task not supported by '#{abcs["test"]["adapter"]}'"
-  end
-
-  if ActiveRecord::Base.connection.supports_migrations?
-    File.open("db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
-  end
-end
-
-desc "Recreate the test databases from the development structure"
-task :clone_structure_to_test => [ :db_structure_dump, :purge_test_database ] do
-  abcs = ActiveRecord::Base.configurations
-  case abcs["test"]["adapter"]
-    when "mysql"
-      ActiveRecord::Base.establish_connection(:test)
-      ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
-      IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |table|
-        ActiveRecord::Base.connection.execute(table)
-      end
-    when "postgresql"
-      ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
-      ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
-      ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
-      `psql -U "#{abcs["test"]["username"]}" -f db/#{RAILS_ENV}_structure.sql #{abcs["test"]["database"]}`
-    when "sqlite", "sqlite3"
-      dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
-      `#{abcs["test"]["adapter"]} #{dbfile} < db/#{RAILS_ENV}_structure.sql`
-    when "sqlserver"
-      `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{RAILS_ENV}_structure.sql`
-    when "oci"
-      ActiveRecord::Base.establish_connection(:test)
-      IO.readlines("db/#{RAILS_ENV}_structure.sql").join.split(";\n\n").each do |ddl|
-        ActiveRecord::Base.connection.execute(ddl)
-      end
-    else 
-      raise "Task not supported by '#{abcs["test"]["adapter"]}'"
-  end
-end
-
-desc "Empty the test database"
-task :purge_test_database => :environment do
-  abcs = ActiveRecord::Base.configurations
-  case abcs["test"]["adapter"]
-    when "mysql"
-      ActiveRecord::Base.establish_connection(:test)
-      ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"])
-    when "postgresql"
-      ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
-      ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
-      ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
-      enc_option = "-E #{abcs["test"]["encoding"]}" if abcs["test"]["encoding"]
-      `dropdb -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
-      `createdb #{enc_option} -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
-    when "sqlite","sqlite3"
-      dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
-      File.delete(dbfile) if File.exist?(dbfile)
-    when "sqlserver"
-      dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
-      `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
-      `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{RAILS_ENV}_structure.sql`
-    when "oci"
-      ActiveRecord::Base.establish_connection(:test)
-      ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
-        ActiveRecord::Base.connection.execute(ddl)
-      end
-    else
-      raise "Task not supported by '#{abcs["test"]["adapter"]}'"
-  end
-end
-
-def prepare_test_database_task
-  {:sql  => :clone_structure_to_test, 
-   :ruby => :clone_schema_to_test}[ActiveRecord::Base.schema_format]
-end
-
-desc 'Prepare the test database and load the schema'
-task :prepare_test_database => :environment do
-  Rake::Task[prepare_test_database_task].invoke
-end
-
-desc "Creates a sessions table for use with CGI::Session::ActiveRecordStore"
-task :create_sessions_table => :environment do
-  raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
-
-  ActiveRecord::Base.connection.create_table :sessions do |t|
-    t.column :session_id, :string
-    t.column :data, :text
-    t.column :updated_at, :datetime
-  end
-  
-  ActiveRecord::Base.connection.add_index :sessions, :session_id
-end
-
-desc "Drop the sessions table"
-task :drop_sessions_table => :environment do
-  raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
-  
-  ActiveRecord::Base.connection.drop_table :sessions
-end
-
-desc "Drop and recreate the session table (much faster than 'DELETE * FROM sessions')"
-task :purge_sessions_table => [ :drop_sessions_table, :create_sessions_table ] do
-end

data/lib/tasks/documentation.rake

@@ -1,76 +0,0 @@
-desc "Generate documentation for the application"
-Rake::RDocTask.new("appdoc") { |rdoc|
-  rdoc.rdoc_dir = 'doc/app'
-  rdoc.title    = "Rails Application Documentation"
-  rdoc.options << '--line-numbers --inline-source'
-  rdoc.rdoc_files.include('doc/README_FOR_APP')
-  rdoc.rdoc_files.include('app/**/*.rb')
-}
-
-plugins = FileList['vendor/plugins/**'].map {|plugin| File.basename(plugin)}
-# Define doc tasks for each plugin
-plugins.each do |plugin|
-  task :"#{plugin}_plugindoc" => :environment do
-    plugin_base   = "vendor/plugins/#{plugin}"
-    options       = []
-    files         = Rake::FileList.new
-    options << "-o doc/plugins/#{plugin}"
-    options << "--title '#{plugin.titlecase} Plugin Documentation'"
-    options << '--line-numbers --inline-source'
-    options << '-T html'
-
-    files.include("#{plugin_base}/lib/**/*.rb")
-    if File.exists?("#{plugin_base}/README")
-      files.include("#{plugin_base}/README")    
-      options << "--main '#{plugin_base}/README'"
-    end
-    files.include("#{plugin_base}/CHANGELOG") if File.exists?("#{plugin_base}/CHANGELOG")
-
-    options << files.to_s
-
-    sh %(rdoc #{options * ' '})
-  end
-end
-
-desc "Generate documation for all installed plugins"
-task :plugindoc => plugins.map {|plugin| :"#{plugin}_plugindoc"}
-
-desc "Remove plugin documentation"
-task :clobber_plugindoc do 
-  rm_rf 'doc/plugins' rescue nil
-end
-
-desc "Generate documentation for the Rails framework"
-Rake::RDocTask.new("apidoc") { |rdoc|
-  rdoc.rdoc_dir = 'doc/api'
-  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
-  rdoc.title    = "Rails Framework Documentation"
-  rdoc.options << '--line-numbers --inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('vendor/rails/railties/CHANGELOG')
-  rdoc.rdoc_files.include('vendor/rails/railties/MIT-LICENSE')
-  rdoc.rdoc_files.include('vendor/rails/activerecord/README')
-  rdoc.rdoc_files.include('vendor/rails/activerecord/CHANGELOG')
-  rdoc.rdoc_files.include('vendor/rails/activerecord/lib/active_record/**/*.rb')
-  rdoc.rdoc_files.exclude('vendor/rails/activerecord/lib/active_record/vendor/*')
-  rdoc.rdoc_files.include('vendor/rails/actionpack/README')
-  rdoc.rdoc_files.include('vendor/rails/actionpack/CHANGELOG')
-  rdoc.rdoc_files.include('vendor/rails/actionpack/lib/action_controller/**/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionpack/lib/action_view/**/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionmailer/README')
-  rdoc.rdoc_files.include('vendor/rails/actionmailer/CHANGELOG')
-  rdoc.rdoc_files.include('vendor/rails/actionmailer/lib/action_mailer/base.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/README')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/CHANGELOG')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/api/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/client/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/container/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/dispatcher/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/protocol/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/actionwebservice/lib/action_web_service/support/*.rb')
-  rdoc.rdoc_files.include('vendor/rails/activesupport/README')
-  rdoc.rdoc_files.include('vendor/rails/activesupport/CHANGELOG')
-  rdoc.rdoc_files.include('vendor/rails/activesupport/lib/active_support/**/*.rb')
-}

data/lib/tasks/framework.rake

@@ -1,71 +0,0 @@
-desc "Lock this application to the current gems (by unpacking them into vendor/rails)"
-task :freeze_gems do
-  deps = %w(actionpack activerecord actionmailer activesupport actionwebservice)
-  require 'rubygems'
-
-  rails = if version = ENV['VERSION']
-            Gem.cache.search('rails', "= #{version}").first
-          else
-            Gem.cache.search('rails').sort_by { |g| g.version }.last
-          end
-  version ||= rails.version
-
-  unless rails
-    puts "No rails gem #{version} is installed.  Do 'gem list rails' to see what you have available."
-    exit
-  end
-
-  puts "Freezing to the gems for Rails #{rails.version}"
-  rm_rf   "vendor/rails"
-  mkdir_p "vendor/rails"
-
-  rails.dependencies.select { |g| deps.include? g.name }.each do |g|
-    system "cd vendor/rails; gem unpack -v '#{g.version_requirements}' #{g.name}; mv #{g.name}* #{g.name}"
-  end
-  system "cd vendor/rails; gem unpack -v '=#{version}' rails"
-  
-  FileUtils.mv(Dir.glob("vendor/rails/rails*").first, "vendor/rails/railties")
-end
-
-desc "Lock this application to the Edge Rails (by exporting from Subversion).  Defaults to svn HEAD; do 'rake freeze_edge REVISION=1234' to lock to a specific revision."
-task :freeze_edge do
-  $verbose = false
-  `svn --version` rescue nil
-  unless !$?.nil? && $?.success?
-    $stderr.puts "ERROR: Must have subversion (svn) available in the PATH to lock this application to Edge Rails"
-    exit 1
-  end
-
-  rm_rf   "vendor/rails"
-  mkdir_p "vendor/rails"
-
-  revision_switch = ENV['REVISION'] ? " -r #{ENV['REVISION']}" : ''
-  for framework in %w( railties actionpack activerecord actionmailer activesupport actionwebservice )
-    mkdir_p "vendor/rails/#{framework}"
-    system  "svn export http://dev.rubyonrails.org/svn/rails/trunk/#{framework}/lib vendor/rails/#{framework}/lib #{revision_switch}"
-  end
-end
-
-desc "Unlock this application from freeze of gems or edge and return to a fluid use of system gems"
-task :unfreeze_rails do
-  rm_rf "vendor/rails"
-end
-
-desc "Add new scripts to the application script/ directory"
-task :add_new_scripts do
-  local_base = "script"
-  edge_base  = "#{File.dirname(__FILE__)}/../../bin"
-
-  local = Dir["#{local_base}/**/*"].reject { |path| File.directory?(path) }
-  edge  = Dir["#{edge_base}/**/*"].reject { |path| File.directory?(path) }
-  
-  edge.each do |script|
-    base_name = script[(edge_base.length+1)..-1]
-    next if base_name == "rails"
-    next if local.detect { |path| base_name == path[(local_base.length+1)..-1] }
-    if !File.directory?("#{local_base}/#{File.dirname(base_name)}")
-      mkdir_p "#{local_base}/#{File.dirname(base_name)}"
-    end
-    install script, "#{local_base}/#{base_name}", :mode => 0755
-  end
-end

data/lib/tasks/javascripts.rake

@@ -1,6 +0,0 @@
-
-desc "Update your javascripts from your current rails install."
-task :update_javascripts do 
-  require 'railties_path'  
-  FileUtils.cp(Dir[RAILTIES_PATH + '/html/javascripts/*.js'], RAILS_ROOT + '/public/javascripts/')
-end

data/lib/tasks/misc.rake

@@ -1,19 +0,0 @@
-desc "Run all the tests on a fresh test database"
-task :default do
-  Rake::Task[:test_units].invoke      rescue got_error = true
-  Rake::Task[:test_functional].invoke rescue got_error = true
-  raise "Test failures" if got_error
-end
-
-task :environment do
-  require(File.join(RAILS_ROOT, 'config', 'environment'))
-end
-
-
-desc "Clears all *.log files in log/"
-task :clear_logs do
-  FileList["log/*.log"].each do |log_file|
-    f = File.open(log_file, "w")
-    f.close
-  end
-end

data/lib/tasks/rails.rb

@@ -1,8 +0,0 @@
-$VERBOSE = nil
-
-# Load Rails rakefile extensions
-Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }
-
-# Load any custom rakefile extensions
-Dir["./lib/tasks/**/*.rake"].sort.each { |ext| load ext }
-Dir["./vendor/plugins/*/tasks/**/*.rake"].sort.each { |ext| load ext }

data/lib/tasks/statistics.rake

@@ -1,16 +0,0 @@
-STATS_DIRECTORIES = [
-  %w(Helpers           app/helpers), 
-  %w(Controllers       app/controllers), 
-  %w(APIs              app/apis),
-  %w(Components        components),
-  %w(Functional\ tests test/functional),
-  %w(Models            app/models),
-  %w(Unit\ tests       test/unit),
-  %w(Libraries         lib/)
-].collect { |name, dir| [ name, "#{RAILS_ROOT}/#{dir}" ] }.select { |name, dir| File.directory?(dir) }
-
-desc "Report code statistics (KLOCs, etc) from the application"
-task :stats do
-  require 'code_statistics'
-  CodeStatistics.new(*STATS_DIRECTORIES).to_s
-end

data/lib/tasks/testing.rake

@@ -1,50 +0,0 @@
-TEST_CHANGES_SINCE = Time.now - 600
-
-# Look up tests for recently modified sources.
-def recent_tests(source_pattern, test_path, touched_since = 10.minutes.ago)
-  FileList[source_pattern].map do |path|
-    if File.mtime(path) > touched_since
-      test = "#{test_path}/#{File.basename(path, '.rb')}_test.rb"
-      test if File.exists?(test)
-    end
-  end.compact
-end
-
-desc 'Test recent changes'
-Rake::TestTask.new(:recent => [ :prepare_test_database ]) do |t|
-  since = TEST_CHANGES_SINCE
-  touched = FileList['test/**/*_test.rb'].select { |path| File.mtime(path) > since } +
-    recent_tests('app/models/*.rb', 'test/unit', since) +
-    recent_tests('app/controllers/*.rb', 'test/functional', since)
-
-  t.libs << 'test'
-  t.verbose = true
-  t.test_files = touched.uniq
-end
-
-desc "Run the unit tests in test/unit"
-Rake::TestTask.new(:test_units => [ :prepare_test_database ]) do |t|
-  t.libs << "test"
-  t.pattern = 'test/unit/**/*_test.rb'
-  t.verbose = true
-end
-
-desc "Run the functional tests in test/functional"
-Rake::TestTask.new(:test_functional => [ :prepare_test_database ]) do |t|
-  t.libs << "test"
-  t.pattern = 'test/functional/**/*_test.rb'
-  t.verbose = true
-end
-
-desc "Run the plugin tests in vendor/plugins/**/test (or specify with PLUGIN=name)"
-Rake::TestTask.new(:test_plugins => :environment) do |t|
-  t.libs << "test"
-  
-  if ENV['PLUGIN']
-    t.pattern = "vendor/plugins/#{ENV['PLUGIN']}/test/**/*_test.rb"
-  else
-    t.pattern = 'vendor/plugins/**/test/**/*_test.rb'
-  end
-
-  t.verbose = true
-end

data/lib/test_help.rb

@@ -1,17 +0,0 @@
-require 'application'
-
-# Make double-sure the RAILS_ENV is set to test, 
-# so fixtures are loaded to the right database
-silence_warnings { RAILS_ENV = "test" }
-
-require 'test/unit'
-require 'active_record/fixtures'
-require 'action_controller/test_process'
-require 'action_web_service/test_invoke'
-require 'breakpoint'
-
-Test::Unit::TestCase.fixture_path = RAILS_ROOT + "/test/fixtures/"
-
-def create_fixtures(*table_names)
-  Fixtures.create_fixtures(RAILS_ROOT + "/test/fixtures", table_names)
-end

data/lib/webrick_server.rb

@@ -1,170 +0,0 @@
-# Donated by Florian Gross
-
-require 'webrick'
-require 'cgi'
-require 'stringio'
-
-include WEBrick
-
-ABSOLUTE_RAILS_ROOT = File.expand_path(RAILS_ROOT)
-
-ActiveRecord::Base.threaded_connections = false
-
-class CGI #:nodoc:
-  def stdinput
-    @stdin || $stdin
-  end
-  
-  def env_table
-    @env_table || ENV
-  end
-  
-  def initialize(type = "query", table = nil, stdin = nil)
-    @env_table, @stdin = table, stdin
-
-    if defined?(MOD_RUBY) && !ENV.key?("GATEWAY_INTERFACE")
-      Apache.request.setup_cgi_env
-    end
-
-    extend QueryExtension
-    @multipart = false
-    if defined?(CGI_PARAMS)
-      warn "do not use CGI_PARAMS and CGI_COOKIES"
-      @params = CGI_PARAMS.dup
-      @cookies = CGI_COOKIES.dup
-    else
-      initialize_query()  # set @params, @cookies
-    end
-    @output_cookies = nil
-    @output_hidden = nil
-  end
-end
-
-# A custom dispatch servlet for use with WEBrick. It dispatches requests
-# (using the Rails Dispatcher) to the appropriate controller/action. By default,
-# it restricts WEBrick to a managing a single Rails request at a time, but you
-# can change this behavior by setting ActionController::Base.allow_concurrency
-# to true.
-class DispatchServlet < WEBrick::HTTPServlet::AbstractServlet
-  REQUEST_MUTEX = Mutex.new
-
-  # Start the WEBrick server with the given options, mounting the
-  # DispatchServlet at <tt>/</tt>.
-  def self.dispatch(options = {})
-    Socket.do_not_reverse_lookup = true # patch for OS X
-
-    params = { :Port        => options[:port].to_i,
-               :ServerType  => options[:server_type],
-               :BindAddress => options[:ip] }
-    params[:MimeTypes] = options[:mime_types] if options[:mime_types]
-
-    server = WEBrick::HTTPServer.new(params)
-    server.mount('/', DispatchServlet, options)
-
-    trap("INT") { server.shutdown }
-
-    require File.join(@server_options[:server_root], "..", "config", "environment") unless defined?(RAILS_ROOT)
-    require "dispatcher"
-
-    server.start
-  end
-
-  def initialize(server, options) #:nodoc:
-    @server_options = options
-    @file_handler = WEBrick::HTTPServlet::FileHandler.new(server, options[:server_root])
-    Dir.chdir(ABSOLUTE_RAILS_ROOT)
-    super
-  end
-
-  def service(req, res) #:nodoc:
-    begin
-      unless handle_file(req, res)
-        REQUEST_MUTEX.lock unless ActionController::Base.allow_concurrency
-        unless handle_dispatch(req, res)
-          raise WEBrick::HTTPStatus::NotFound, "`#{req.path}' not found."
-        end
-      end
-    ensure
-      unless ActionController::Base.allow_concurrency
-        REQUEST_MUTEX.unlock if REQUEST_MUTEX.locked?
-      end
-    end
-  end
-
-  def handle_file(req, res) #:nodoc:
-    begin
-      req = req.dup
-      path = req.path.dup
-
-      # Add .html if the last path piece has no . in it
-      path << '.html' if path != '/' && (%r{(^|/)[^./]+$} =~ path) 
-      path.gsub!('+', ' ') # Unescape + since FileHandler doesn't do so.
-
-      req.instance_variable_set(:@path_info, path) # Set the modified path...
-
-      @file_handler.send(:service, req, res)      
-      return true
-    rescue HTTPStatus::PartialContent, HTTPStatus::NotModified => err
-      res.set_error(err)
-      return true
-    rescue => err
-      return false
-    end
-  end
-
-  def handle_dispatch(req, res, origin = nil) #:nodoc:
-    data = StringIO.new
-    Dispatcher.dispatch(
-      CGI.new("query", create_env_table(req, origin), StringIO.new(req.body || "")), 
-      ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS, 
-      data
-    )
-
-    header, body = extract_header_and_body(data)
-
-    set_charset(header)
-    assign_status(res, header)
-    res.cookies.concat(header.delete('set-cookie') || [])
-    header.each { |key, val| res[key] = val.join(", ") }
-    
-    res.body = body
-    return true
-  rescue => err
-    p err, err.backtrace
-    return false
-  end
-  
-  private
-    def create_env_table(req, origin)
-      env = req.meta_vars.clone
-      env.delete "SCRIPT_NAME"
-      env["QUERY_STRING"] = req.request_uri.query
-      env["REQUEST_URI"]  = origin if origin
-      return env
-    end
-    
-    def extract_header_and_body(data)
-      data.rewind
-      data = data.read
-
-      raw_header, body = *data.split(/^[\xd\xa]+/on, 2)
-      header = WEBrick::HTTPUtils::parse_header(raw_header)
-      
-      return header, body
-    end
-    
-    def set_charset(header)
-      ct = header["content-type"]
-      if ct.any? { |x| x =~ /^text\// } && ! ct.any? { |x| x =~ /charset=/ }
-        ch = @server_options[:charset] || "UTF-8"
-        ct.find { |x| x =~ /^text\// } << ("; charset=" + ch)
-      end
-    end
-
-    def assign_status(res, header)
-      if /^(\d+)/ =~ header['status'][0]
-        res.status = $1.to_i
-        header.delete('status')
-      end
-    end
-end