#!/usr/bin/env ruby
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# 
$LOAD_PATH.unshift File.dirname(__FILE__) + '/../vendor/plugins/rspec/lib' # For rspec installed as plugin
require 'rubygems'
require 'drb/drb'
require 'rbconfig'
require 'spec'
require 'optparse'

# This is based on Florian Weber's TDDMate
module Spec
  module Runner
    class RailsSpecServer
      def run(argv, stderr, stdout)
        $stdout = stdout
        $stderr = stderr

        base = ActiveRecord::Base
        def base.clear_reloadable_connections!
          active_connections.each do |name, conn|
            if conn.requires_reloading?
              conn.disconnect!
              active_connections.delete(name)
            end
          end
        end

        if ActionController.const_defined?(:Dispatcher)
          dispatcher = ::ActionController::Dispatcher.new($stdout)
          dispatcher.cleanup_application
        elsif ::Dispatcher.respond_to?(:reset_application!)
          ::Dispatcher.reset_application!
        else
          raise "Application reloading failed"
        end
        if Object.const_defined?(:Fixtures) && Fixtures.respond_to?(:reset_cache)
          Fixtures.reset_cache
        end

        ::Dependencies.mechanism = :load
        require_dependency('application.rb') unless Object.const_defined?(:ApplicationController)
        load File.dirname(__FILE__) + '/../spec/spec_helper.rb'

        if in_memory_database?
          load "#{RAILS_ROOT}/db/schema.rb" # use db agnostic schema by default
          ActiveRecord::Migrator.up('db/migrate') # use migrations
        end

        ::Spec::Runner::CommandLine.run(
          ::Spec::Runner::OptionParser.parse(
            argv,
            $stderr,
            $stdout
          )
        )
      end

      def in_memory_database?
        ENV["RAILS_ENV"] == "test" and
        ::ActiveRecord::Base.connection.class.to_s == "ActiveRecord::ConnectionAdapters::SQLite3Adapter" and
        ::Rails::Configuration.new.database_configuration['test']['database'] == ':memory:'
      end
    end
  end
end
puts "Loading Rails environment"

ENV["RAILS_ENV"] = "test"
require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
require 'dispatcher'

def restart_test_server
  puts "restarting"
  config       = ::Config::CONFIG
  ruby         = File::join(config['bindir'], config['ruby_install_name']) + config['EXEEXT']
  command_line = [ruby, $0, ARGV].flatten.join(' ')
  exec(command_line)
end

def daemonize(pid_file = nil)
  return yield if $DEBUG
  pid = Process.fork{
    Process.setsid
    Dir.chdir(RAILS_ROOT)
    trap("SIGINT"){ exit! 0 }
    trap("SIGTERM"){ exit! 0 }
    trap("SIGHUP"){ restart_test_server }
    File.open("/dev/null"){|f|
      STDERR.reopen f
      STDIN.reopen  f
      STDOUT.reopen f
    }
    yield
  }
  puts "spec_server launched. (PID: %d)" % pid
  File.open(pid_file,"w"){|f| f.puts pid } if pid_file
  exit! 0
end

options = Hash.new
opts = OptionParser.new
opts.on("-d", "--daemon"){|v| options[:daemon] = true }
opts.on("-p", "--pid PIDFILE"){|v| options[:pid] = v }
opts.parse!(ARGV)

puts "Ready"
exec_server = lambda {
  trap("USR2") { restart_test_server } if Signal.list.has_key?("USR2")
  DRb.start_service("druby://127.0.0.1:8989", Spec::Runner::RailsSpecServer.new)
  DRb.thread.join
}

if options[:daemon]
  daemonize(options[:pid], &exec_server)
else
  exec_server.call
end