dohruby 0.2.1 → 0.3

data/CHANGELOG

@@ -121,3 +121,11 @@
  * added create_database.rb to deploy executables list
 *0.2.1* (Jun 20th, 2008)
  * added util/to_display
+*0.2.2*
+ * simplify Dir related code
+ * doh/mysql - merge hash_util into Handle class
+ * doh/mysql - misc Handle tweaks, enhancements
+ * moved post_hash to doh/util from doh/merb
+ * added get_required_config_value that raises if the value doesn't exist in the config (with description of error)
+ * added xml_util for hash to xml, vice versa, and http_handler
+

data/bin/config.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+require 'doh/boot/app_pwd'
+
+opts = DohApp::Options.new(
+{'check' => [false, "-c", "--check", "checks for the presence of all listed config keys. exits with non-zero status code if any are missing"] \
+,'file' => [nil, "-f", "--file <filename>", "filename to read the config key names from"] \
+,'show' => [false, "-s", "--show", "shows a list of defined config entries"] \
+,'keys' => [false, "-k", "--keys", "shows a list of defined config keys (useful for generating a file to read from)"] \
+}, true, 'list of config keys. only used with some options. nested keys are not yet supported, but ultimately will be in path style.')
+
+class DisplayConfig
+  def self.run
+    DohApp::config.keys.sort.each do |key|
+      nested(key, DohApp::config[key])
+    end
+  end
+
+private
+  def self.nested(top_key, top_obj, tab_level = 0)
+    indent = ' ' * (tab_level * 2)
+    if top_obj.is_a?(Hash)
+      puts "#{indent}#{top_key}:"
+      top_obj.keys.each {|key| nested(key, top_obj[key], tab_level + 1)}
+    else
+      puts "#{indent}#{top_key} -> #{top_obj.inspect}"
+    end
+  end
+end
+
+class CheckConfig
+  def self.run(keys_to_check)
+    missing = []
+    keys_to_check.each do |key|
+      missing.push(key) unless DohApp::config.key?(key)
+    end
+
+    if missing.empty?
+      puts "checked #{keys_to_check.size} keys; all are present"
+      exit 0
+    else
+      puts "failing due to missing keys: #{missing.join(',')}"
+      exit 1
+    end
+  end
+end
+
+if opts.show
+  DisplayConfig.run
+elsif opts.keys
+  DohApp::config.keys.sort.each { |key| puts key }
+elsif opts.check
+  if opts.file
+    keys_to_check = []
+    File.new(opts.file, 'r').each_line { |line| keys_to_check.push(line.chomp) }
+  else
+    keys_to_check = opts.varargs
+  end
+  CheckConfig.run(keys_to_check)
+else
+  puts opts
+end

data/bin/create_database.rb

@@ -1,20 +1,27 @@
 #!/usr/bin/env ruby
-require 'doh/app_pwd'
+require 'doh/boot/app_pwd'
 require 'doh/mysql/database_creator'
 
 opts = DohApp::Options.new(
-{'drop_first' => [false, "-z", "--drop_first", "if true, will drop the database before creating it"] \
-,'database' => [DohApp::config['primary_database'], "-d", "--database <database>", "name of the database to create -- defaults to config['primary_database'], currently '#{DohApp::config['primary_database']}'"] \
+{'drop_first' => [false, "-z", "--drop_first", "if true, will drop the database or tables before creating"] \
+,'database' => [DohApp::config['primary_database'], "-d", "--database <database>", "name of the source database -- defaults to config['primary_database'], currently '#{DohApp::config['primary_database']}'"] \
 ,'all' => [false, "-a", "--all", "create all databases"] \
+,'target' => [DohApp::config['target_database'], "-g", "--target <database>", "name of the target database -- defaults to same as source"] \
+,'tables' => [nil, "-t", "--tables <tables>", "comma-delimited list of tables to create; if specified, no databases are dropped or created"]
 })
 
-if opts.database.to_s.empty?
-  puts "You must specify a database (either here with -d or in your config)"
+if opts.database.to_s.empty? && !opts.all
+  puts "You must specify a database (either here with -d or in your config) or all (with -a)"
   exit 1
 end
+
 db_creator = DohDb::DatabaseCreator.new
-if opts.all
+if opts.tables
+  db_creator.create_tables(opts.database, opts.drop_first, opts.tables.split(/,/))
+elsif opts.all
   db_creator.create_all_databases(opts.drop_first)
+elsif opts.target
+  db_creator.create_database_copy(opts.target, opts.database, opts.drop_first)
 else
   db_creator.create_database(opts.database, opts.drop_first)
 end

data/bin/gendata.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require 'doh/boot/app_pwd'
+require 'doh/data/catalog'
+require 'doh/data/require_datagen'
+require 'doh/mysql/connector_util'
+DohData::require_datagen
+
+opts = DohApp::Options.new(
+{'target' => [DohApp::config['primary_database'], "-g", "--target <database>", "name of the target database -- defaults to config['primary_database'], currently '#{DohApp::config['primary_database']}'"] \
+,'count' => [1, "-c", "--count <amount>", "how many to create"] \
+}, true, 'list of catalog entries to create')
+
+if opts.varargs.size == 0
+  DohData::catalog_list.each {|elem| puts elem }
+  exit
+end
+
+if opts.target
+  DohDb::reconfigure_connector({'database' => opts.target})
+end
+
+opts.varargs.each do |entry|
+  klass = DohData::search_catalog(entry)
+  if klass.nil?
+    puts "unable to find data object matching: #{entry}"
+  else
+    Doh::disable_logging
+    opts.count.to_i.times do
+      begin
+        klass.new.save_to_database
+#      rescue Exception => excpt
+#        puts "ignoring exception: #{excpt.inspect}"
+      end
+    end
+  end
+end
+

data/bin/migrate.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+require 'doh/boot/app_pwd'
+require 'doh/mysql/migrate'
+require 'doh/mysql/version'
+require 'doh/mysql/migrate_check'
+
+opts = DohApp::Options.new(
+{'database' => [DohApp::config['primary_database'], "-d", "--database <database>", "name of the database to migrate -- defaults to config['primary_database'], currently '#{DohApp::config['primary_database']}'"] \
+,'all' => [false, "-a", "--all", "operate on all databases"] \
+,'update' => [true, "-u", "--update", "migrate to the latest version (this is the default action)"] \
+,'rollback' => [nil, "-r", "--rollback", "rollback one version"] \
+,'version' => [nil, "-v", "--version <version>", "migrate to a specific version"] \
+,'check' => [false, "-c", "--check", "check the current unlocked migration for validity (no migrations will take place)"] \
+,'lock' => [false, "-l", "--lock", "lock the current unlocked migration, if any (no migrations will take place)"] \
+,'make_new' => [false, "-m", "--make-new", "make a new unlocked migration (or return the filenames of the current one if one already exists)"] \
+})
+
+if opts.database.to_s.empty? && !opts.all
+  puts "You must specify a database (either here with -d or in your config) or all (with -a)"
+  exit 1
+end
+
+if opts.all
+  database_ary = Dir.directories(File.join(DohApp::home, 'database'))
+else
+  database_ary = [opts.database]
+end
+
+database_ary.each do |database|
+  if opts.check || opts.lock || opts.make_new
+    if opts.check
+      success, msg = DohDb::MigrateChecker.new(database).run
+    elsif opts.lock
+      success, msg = DohDb::update_locked_file(database)
+    elsif opts.make_new
+      success, msg = DohDb::DatabaseMigrator.new(database).get_unlocked_migration
+    end
+
+    if success
+      puts "'#{database}': succcess - " + msg
+    else
+      puts "***************** FAILURE for '#{database}' **********************"
+      puts msg
+      exit 1
+    end
+
+    next
+  end
+
+  dbmigrator = DohDb::DatabaseMigrator.new(database)
+  fret = if opts.version
+    dbmigrator.make_version(opts.version.to_i)
+  elsif opts.rollback
+    dbmigrator.rollback
+  else
+    dbmigrator.update
+  end
+
+  if fret.nil?
+    dohlog.info("'#{database}': no migration occurred")
+  else
+    msg = "'#{database}': version migrated from #{fret.first} to #{fret.last}"
+    dohlog.notify(msg)
+    puts msg
+  end
+end

data/bin/{rcov-preprocess-files.rb → rcov_preprocess_files.rb}

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-require 'doh/util/options'
+require 'doh/boot/options'
 require 'doh/core/dir'
 require 'ruby_parser'
 require 'ruby2ruby'

data/bin/run_tests.rb

@@ -1,11 +1,14 @@
 #!/usr/bin/env ruby
-require 'doh/app/options'
+require 'doh/boot/options'
 
 opts = DohApp::Options.new(
 {'filter' => [nil, "-f", "--filter <name>", "name or partial name of test method(s) to execute."] \
 ,'force_production' => [false, "-p", "--force_production", "override config to run only production (p, q) tests."] \
-,'force_development' => [false, "-d", "--force_development", "override config to run only dev (d, p, i) tests."] \
+,'force_development' => [false, "-d", "--force_development", "override config to run only dev (d, p) tests."] \
+,'run_slow_tests' => [false, "-s", "--run_slow_tests", "runs slow tests."] \
 ,'repeat' => [1, "-r", "--repeat <times>", "number of times to repeat the tests."] \
+,'growl_notify' => [false, "-g", "--growl", "notifies via growl if something fails"] \
+,'seed' => [(Time.new.to_f * 1000).to_i, "-v", "--seed <seed_value>", "random seed"] \
 }, true, 'Files or directories may be specified to run tests on.  Directories will be treated recursively.  Defaults to the current directory.')
 
 def get_args_without_repeat(argv)
@@ -41,11 +44,18 @@ if repeat_count > 1
   end
 else
   require 'doh/app/init_unit_test'
-  require 'doh/test/run_tests'
   DohApp::init_unit_test(start_dir)
+  require 'doh/test/run_tests'
+  dohlog.info("*******Using seed: #{opts.seed} for this test run")
+  srand(opts.seed.to_i)
+
   prod_flag = (DohApp::config['include_production_tests'] || opts.force_production) && !opts.force_development
+  ran_tests = false
   args.each do |arg|
-    DohTest::run_tests(arg, prod_flag, opts.filter)
+    ran_tests = DohTest::run_tests(arg, prod_flag, opts.run_slow_tests, opts.filter, opts.growl_notify) || ran_tests
+  end
+  if !ran_tests
+    puts "No files were loaded."
+    exit(1)
   end
 end
-

data/bin/update_rdoc.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'doh/boot/app_pwd'
+require 'doh/core/dir'
+require 'fileutils'
+
+class UpdateRdoc
+  def run
+    do_subdir('lib')
+    apps_dir = File.join(DohApp::home, 'apps')
+    if File.directory?(apps_dir)
+      Dir.directories(apps_dir).each { |elem| do_subdir('apps/' + elem) }
+    end
+  end
+
+private
+  def do_subdir(dest_subdir, src_subdir = nil)
+    src_dir = File.join(DohApp::home, src_subdir || dest_subdir)
+    return unless File.directory?(src_dir)
+    FileUtils::cd(src_dir)
+
+    dest_dir = File.join(DohApp::home, 'doc/source', dest_subdir)
+    cmd = "rdoc -aq -S --op #{dest_dir}"
+    dohlog.debug("executing: #{cmd}")
+    `#{cmd}`
+  end
+end
+
+UpdateRdoc.new.run

data/lib/doh/app/activate_database.rb

@@ -1,5 +1,4 @@
 require 'doh/app/config'
-require 'doh/mysql'
 
 module DohApp
 
@@ -9,19 +8,13 @@ def self.activate_database
   return unless root_cfg.key?('database')
   db_cfg = root_cfg['database']
   require 'doh/mysql'
+  require 'doh/mysql/require_dbtypes'
   conn = DohDb::CacheConnector.new(db_cfg['host'], db_cfg['username'], db_cfg['password'], db_cfg['database'] || root_cfg['primary_database'])
-  row_builder = db_cfg['row_builder'] || root_cfg['row_builder'] || 'typed'
-  if row_builder.is_a?(Class)
-    conn.row_builder = row_builder
-  elsif row_builder == 'typed'
-    require 'doh/mysql/typed_row_builder'
-    conn.row_builder = DohDb::TypedRowBuilder
-  elsif row_builder == 'raw'
-    # that's the default for the CacheConnector, don't need to do anything
-  else
-    raise "unrecognized database row_builder: #{row_builder.inspect}"
-  end
+  conn.port = db_cfg['port']
+  conn.timeout = db_cfg['timeout'].to_i if db_cfg['timeout']
+  conn.row_builder = db_cfg['row_builder'] || root_cfg['row_builder']
   DohDb::set_connector_instance(conn)
+  DohDb::require_dbtypes
 end
 
 end

data/lib/doh/app/activate_logger.rb

@@ -1,5 +1,6 @@
 require 'doh/app/config'
 require 'doh/logger/severity'
+require 'doh/logger/socket_acceptor'
 
 module DohApp
 
@@ -25,39 +26,54 @@ def self.activate_logger
 
   # initialize logfile_name here, so it can be used later in the email acceptors below
   logfile_name = 'none'
-  if acceptor_cfg = logger_cfg['file_acceptor']
-    if acceptor_cfg.fetch('unique_filename', false)
+  if logger_cfg['enable_file_acceptor']
+    acceptor_cfg = logger_cfg['file_acceptor']
+    logfile_name = acceptor_cfg['filename']
+    if !logfile_name.nil?
+      # don't set it
+    elsif acceptor_cfg.fetch('unique_filename', false)
       logfile_name = File.basename($PROGRAM_NAME, '.rb') + ".#{Process.pid}" + '.log'
     else
       logfile_name = File.basename($PROGRAM_NAME, '.rb') + '.log'
     end
+    logfile_name = File.join(acceptor_cfg['log_directory'], logfile_name) if acceptor_cfg['log_directory']
     logfile = File.new(logfile_name, "w+")
     logfile.sync = true if acceptor_cfg.fetch('flush', false)
     file_acceptor = DohLogger::IOStreamAcceptor.new(logfile)
     file_acceptor.flush_always if acceptor_cfg.fetch('flush', false)
-    Doh::log.add_acceptor(translate_logger_level(acceptor_cfg.fetch('severity', 'debug')), file_acceptor)
+    Doh::log.add_acceptor(translate_logger_level(acceptor_cfg.fetch('severity', 'debug')), file_acceptor, nil, acceptor_cfg['locations_to_exclude'], acceptor_cfg['include_only_locations'])
   end
 
-  if acceptor_cfg = logger_cfg['stdout_acceptor']
-    Doh::log.add_acceptor(translate_logger_level(acceptor_cfg.fetch('severity', 'debug')), DohLogger::IOStreamAcceptor.new)
+  if logger_cfg['enable_socket_acceptor']
+    acceptor_cfg = logger_cfg['socket_acceptor']
+    socket_acceptor = DohLogger::SocketAcceptor.new(acceptor_cfg.fetch('ip_addr', '127.0.0.1'), acceptor_cfg.fetch('port', DohLogger::SocketAcceptor::default_port))
+    Doh::log.add_acceptor(translate_logger_level(acceptor_cfg.fetch('severity', 'debug')), socket_acceptor, nil, acceptor_cfg['locations_to_exclude'], acceptor_cfg['include_only_locations'])
   end
 
-  if acceptor_cfg = logger_cfg['notify_acceptor']
+  if logger_cfg['enable_stdout_acceptor']
+    acceptor_cfg = logger_cfg['stdout_acceptor']
+    locations_to_exclude = acceptor_cfg.key?('locations_to_exclude') ? acceptor_cfg['locations_to_exclude'] : ['DohDb']
+    Doh::log.add_acceptor(translate_logger_level(acceptor_cfg.fetch('severity', 'debug')), DohLogger::IOStreamAcceptor.new, nil, locations_to_exclude, acceptor_cfg['include_only_locations'])
+  end
+
+  if logger_cfg['enable_notify_acceptor']
+    acceptor_cfg = logger_cfg['notify_acceptor']
     require 'doh/logger/email_acceptor'
-    mail_server = root_cfg['mail_server'] || 'mail.' + root_cfg['domain_name']
-    from_address = acceptor_cfg['from_address'] || 'notify@' + root_cfg['domain_name']
+    mail_server = root_cfg['mail_server'] || 'mail.' + get_required_config_value('domain_name', 'mail_server or domain_name required for mail server')
+    from_address = acceptor_cfg['from_address'] || 'notify@' + get_required_config_value('domain_name', 'from_address or domain_name required for notification email address')
     to_address_list = acceptor_cfg['to_address_list'] || ['root@localhost']
     notify_acceptor = DohLogger::EmailAcceptor.new(mail_server, from_address, to_address_list, logfile_name, nil, DohLogger::exceptionless_email_format)
-    Doh::log.add_acceptor(DohLogger::NOTIFY, notify_acceptor, true)
+    Doh::log.add_acceptor(DohLogger::NOTIFY, notify_acceptor, true, acceptor_cfg['locations_to_exclude'], acceptor_cfg['include_only_locations'])
   end
 
-  if acceptor_cfg = logger_cfg['error_acceptor']
+  if logger_cfg['enable_error_acceptor']
+    acceptor_cfg = logger_cfg['error_acceptor']
     require 'doh/logger/email_acceptor'
-    mail_server = root_cfg['mail_server'] || 'mail.' + root_cfg['domain_name']
-    from_address = acceptor_cfg['from_address'] || 'error@' + root_cfg['domain_name']
+    mail_server = root_cfg['mail_server'] || 'mail.' + get_required_config_value('domain_name', 'mail_server or domain_name required for mail server')
+    from_address = acceptor_cfg['from_address'] || 'error@' + get_required_config_value('domain_name', 'from_address or domain_name required for notification email address')
     to_address_list = acceptor_cfg['to_address_list'] || ['root@localhost']
     error_acceptor = DohLogger::EmailAcceptor.new(mail_server, from_address, to_address_list, logfile_name)
-    Doh::log.add_acceptor(DohLogger::ERROR, error_acceptor)
+    Doh::log.add_acceptor(DohLogger::ERROR, error_acceptor, nil, acceptor_cfg['locations_to_exclude'], acceptor_cfg['include_only_locations'])
   end
 end
 

data/lib/doh/app/config.rb

@@ -1,4 +1,5 @@
 require 'doh/app/home'
+require 'doh/logger/socket_acceptor'
 
 module DohApp
 
@@ -13,4 +14,21 @@ def self.config
   @@config
 end
 
+def self.get_required_config_value(value, desc)
+  raise "Attempt to get configuration value: #{value.inspect}, but none exists.  #{desc}" if !config.key?(value)
+  config[value]
+end
+
+def self.enable_notifies
+  logger_cfg = @@config['logger']
+  logger_cfg['enable_notify_acceptor'] = true
+  logger_cfg['enable_error_acceptor'] = true
+end
+
+def self.enable_socket_acceptor(port = DohLogger::SocketAcceptor::default_port)
+  logger_cfg = @@config['logger']
+  logger_cfg['enable_socket_acceptor'] = true
+  logger_cfg['socket_acceptor']['port'] = port
+end
+
 end

data/lib/doh/app/home.rb

@@ -1,3 +1,5 @@
+require 'doh/home'
+
 module DohApp
 
 def self.home
@@ -6,14 +8,7 @@ def self.home
 end
 
 def self.find_home(dir, max_tries = 20)
-  path = File.expand_path(dir)
-  raise "unable to find a DohApp home" if (path == '/') || (max_tries <= 0)
-
-  if File.exist?(File.join(path, 'dohapp_home'))
-    @@home = path
-  else
-    find_home(File.join(path, '..'), max_tries - 1)
-  end
+  @@home = Doh::find_file_in_parents(dir, 'dohapp_home', max_tries = 20)
 end
 
 end

data/lib/doh/app/init_runnable.rb

@@ -6,12 +6,25 @@ module DohApp
 
 def self.use_default_runnable_production_config
   root_cfg = DohApp::config
-  file_acceptor_cfg = {'unique_filename' => true, 'flush' => false, 'severity' => 'debug'}
+  logger_cfg = {}
+
+  logger_cfg['file_acceptor'] = {'unique_filename' => true, 'flush' => false, 'severity' => 'debug'}
+  logger_cfg['enable_file_acceptor'] = true
+
   email_acceptor_cfg = {'to_address_list' => ["notify@#{DohApp::config['domain_name']}"]}
-  logger_cfg = {'file_acceptor' => file_acceptor_cfg, 'notify_acceptor' => email_acceptor_cfg, 'error_acceptor' => email_acceptor_cfg.dup}
+  logger_cfg['notify_acceptor'] = email_acceptor_cfg
+  logger_cfg['error_acceptor'] = email_acceptor_cfg.dup
+  logger_cfg['enable_notify_acceptor'] = true
+  logger_cfg['enable_error_acceptor'] = true
+  logger_cfg['stdout_acceptor'] = {'severity' => 'debug'}
+  logger_cfg['enable_stdout_acceptor'] = false
+  logger_cfg['socket_acceptor'] = {'severity' => 'info'}
+  logger_cfg['enable_socket_acceptor'] = false
+
   root_cfg['logger'] = logger_cfg
   root_cfg['enable_logger'] = true
   root_cfg['host_files_directory'] = '/etc'
+  root_cfg['environment'] = 'production'
 
   require 'doh/util/internal_ip'
   Doh::set_source_ip(Doh::internal_ip)
@@ -19,14 +32,27 @@ end
 
 def self.use_default_runnable_development_config
   root_cfg = DohApp::config
-  file_acceptor_cfg = {'unique_filename' => false, 'flush' => true, 'severity' => 'debug'}
-  stdout_acceptor_cfg = {'severity' => 'debug'}
-  logger_cfg = {'file_acceptor' => file_acceptor_cfg, 'stdout_acceptor' => stdout_acceptor_cfg}
+  logger_cfg = {}
+
+  logger_cfg['file_acceptor'] = {'unique_filename' => false, 'flush' => true, 'severity' => 'debug'}
+  logger_cfg['enable_file_acceptor'] = true
+
+  email_acceptor_cfg = {'to_address_list' => ['root@localhost']}
+  logger_cfg['notify_acceptor'] = email_acceptor_cfg
+  logger_cfg['error_acceptor'] = email_acceptor_cfg.dup
+  logger_cfg['enable_notify_acceptor'] = false
+  logger_cfg['enable_error_acceptor'] = false
+  logger_cfg['stdout_acceptor'] = {'severity' => 'debug'}
+  logger_cfg['enable_stdout_acceptor'] = true
+  logger_cfg['socket_acceptor'] = {'severity' => 'debug'}
+  logger_cfg['enable_socket_acceptor'] = false
+
   root_cfg['logger'] = logger_cfg
   root_cfg['enable_logger'] = true
   root_cfg['host_files_directory'] = '~/.dohruby'
   root_cfg['mail_server'] = 'localhost'
   root_cfg['database'] = {'username' => 'root', 'host' => 'localhost'}
+  root_cfg['environment'] = 'development'
 
   Doh::set_source_ip('127.0.0.1')
 end
@@ -40,7 +66,13 @@ def self.init_runnable(file_or_directory, block = nil)
   end
   block.call(DohApp::config) if block
   DohApp::activate_logger
-  DohApp::activate_database
+  unless DohApp::config['dont_activate_database']
+    DohApp::activate_database
+  end
+end
+
+def self.init_runnable_dir(file_or_directory, &block)
+  DohApp::init_runnable(file_or_directory, block)
 end
 
 def self.init_runnable_prog(&block)
@@ -48,8 +80,7 @@ def self.init_runnable_prog(&block)
 end
 
 def self.init_runnable_pwd(&block)
-  require 'fileutils'
-  init_runnable(FileUtils::pwd, block)
+  init_runnable(Dir.pwd, block)
 end
 
 end

data/lib/doh/app/init_script.rb

@@ -0,0 +1,19 @@
+#this is for non-database applications that want logging
+#in order to enable database, call DohApp::activate_database
+
+require 'doh/app/init_runnable'
+require 'doh/app/options'
+home = ENV['DOH_HOME'] || '/etc/doh'
+homefile = File.join(home, 'dohapp_home')
+if !File.exists?(homefile)
+  raise "a file: '#{homefile}' must exist in a directory where you can create configuration information -- the file can be empty"
+end
+logdir = ENV['DOH_LOG_DIR'] || File.join(home, 'logs')
+if !File.exists?(logdir)
+  raise "a directory: '#{logdir}' must exist for logs"
+end
+
+DohApp::init_runnable_dir(home) do |config|
+  config['logger']['file_acceptor']['log_directory'] = logdir
+  config['dont_activate_database'] = true
+end

data/lib/doh/app/init_unit_test.rb

@@ -5,10 +5,12 @@ module DohApp
 def self.use_default_unit_test_development_config
   DohApp::config['database'] = {'username' => 'root', 'host' => 'localhost'}
   DohApp::config['include_production_tests'] = false
+  DohApp::config['environment'] = 'development'
 end
 
 def self.use_default_unit_test_production_config
- DohApp::config['include_production_tests'] = true
+  DohApp::config['include_production_tests'] = true
+  DohApp::config['environment'] = 'production'
 end
 
 def self.init_unit_test(file_or_directory)
@@ -18,6 +20,7 @@ def self.init_unit_test(file_or_directory)
       DohApp::use_default_unit_test_development_config
     end
   end
+  DohApp::config['testing'] = true
 end
 
 end

data/lib/doh/app_no_stdio.rb

@@ -1,2 +1,2 @@
 require 'doh/app/init_runnable'
-DohApp::init_runnable_prog {|cfg| cfg['logger'].delete('stdout_acceptor')}
+DohApp::init_runnable_prog { |cfg| cfg['logger']['enable_stdout_acceptor'] = false }

data/lib/doh/boot/app.rb

@@ -0,0 +1,2 @@
+require 'doh/boot/find_dohruby'
+require 'doh/app'

data/lib/doh/boot/app_pwd.rb

@@ -0,0 +1,2 @@
+require 'doh/boot/find_dohruby'
+require 'doh/app_pwd'

data/lib/doh/boot/find_dohruby.rb

@@ -0,0 +1,5 @@
+if RUBY_VERSION =~ /1\.8\./ then
+  require 'doh/boot/find_dohruby_18'
+else
+  require 'doh/boot/find_dohruby_19'
+end

data/lib/doh/boot/find_dohruby_18.rb

@@ -0,0 +1,37 @@
+module DohBoot
+
+@@start_path = nil
+#we want to start looking for dohruby at the first non-require file after we've seen doh/boot
+current_caller = caller
+seen_doh_boot = false
+current_caller.each_with_index do |path, index|
+  seen_doh_boot ||= (path =~ /doh\/boot/)
+  current_caller[index] =~ /^([^:]*):/
+  currentfile = $1
+  current_caller[index+1] =~ /^([^:]*):/
+  nextfile = $1
+  if !@@start_path && seen_doh_boot && path =~ /require\.rb\:\d+\:in \`require\'$/ && (nextfile != currentfile) && (current_caller[index+1] =~ /.*\d+$/)
+    @@start_path = nextfile
+    break
+  end
+end
+
+def self.find_dohruby_in_parents(dir, max_tries = 20)
+  path = File.expand_path(dir)
+  raise "unable to find dohruby" if (path == '/') || (max_tries <= 0)
+
+  if File.exist?(File.join(path, 'dohruby'))
+    return File.join(path, 'dohruby')
+  else
+    return find_dohruby_in_parents(File.join(path, '..'), max_tries - 1)
+  end
+end
+
+if !$LOAD_PATH.find {|dir| dir =~ /dohruby\/lib/}
+  dohruby_path = DohBoot::find_dohruby_in_parents(File.dirname(@@start_path))
+  if File.exist?(dohruby_path)
+    $LOAD_PATH.push(File.join(dohruby_path, 'lib'))
+  end
+end
+
+end