#
#
# patch "cert.cc"
#  from [fcc2f9d9834036780cd4dabe1d2c79be7e75294e]
#    to [c12de2f48d939f57987b14d1a1d73d90bb05e7a2]
# 
# patch "cert.hh"
#  from [181746202c1ccb83aee14a11ec0c76d0f7c36f13]
#    to [c02a471d86e12a1e65436c0f93b76ff9a5268788]
# 
# patch "cmd_db.cc"
#  from [c8d2b577696e88f1588b56ceb60e4e3a8fea308a]
#    to [89bba58eaa5389a79297ed1cda4ae6fa9f8d3726]
# 
# patch "cmd_key_cert.cc"
#  from [88455e8ba65a5f90f31fcadb9649e35725ae477f]
#    to [54ee3b62be8731cc525c8fc9060f5474cc884e99]
# 
# patch "cmd_merging.cc"
#  from [397e1c8cfbabaa94eb61d17f0e7154eef1e6f2eb]
#    to [dfb1096757dbdab93830d992d67e0562f04064eb]
# 
# patch "cmd_netsync.cc"
#  from [adda0fbd68bbc375c1e271963fe41bb09077d798]
#    to [1e1d50899fd1bf98e7af49773820a205c195ec8f]
# 
# patch "database.cc"
#  from [5c68207981f7599b76d2fcad1f60d9770ed6d709]
#    to [5dea9bcb9b63912a2777d21681a019d0445c010b]
# 
# patch "database.hh"
#  from [4ec4892a81f140da06caf418f89dad9c6ae803d7]
#    to [22a1713bf1f5346faab35220b8846f905e1abfac]
# 
# patch "project.cc"
#  from [5cb6f6d5a962d7732d74525d5be972b53b6d67e1]
#    to [7ee05b374c4adb790c8b3b08f0d91bd04c22447a]
# 
# patch "revision.cc"
#  from [1712b1a74c33ee04480125d5e1a923770aec2ccb]
#    to [179d8cabfa40a2ebb1433dae86b2d6fb81a88882]
# 
# patch "update.cc"
#  from [4c5451ee4e1f2e3e549cff753b88c6d4d47f3934]
#    to [370ff546900209b02ac77b6fe2e9dc3a9ffc1932]
# 
# patch "update.hh"
#  from [3bd04ff46a2287f0d679894af43d4edd89c3707e]
#    to [2dc36b9ef125c3861bf4e45477caf1d29b7daa78]
#
============================================================
--- cert.cc	fcc2f9d9834036780cd4dabe1d2c79be7e75294e
+++ cert.cc	c12de2f48d939f57987b14d1a1d73d90bb05e7a2
@@ -545,10 +545,10 @@ cert_revision_suspended_in_branch(revisi
 void
 cert_revision_suspended_in_branch(revision_id const & rev,
                         branch_name const & branch,
-                        app_state & app)
+                        database & db)
 {
   put_simple_revision_cert (rev, suspend_cert_name, cert_value(branch()),
-                            app);
+                            db);
 }
 
 
============================================================
--- cert.hh	181746202c1ccb83aee14a11ec0c76d0f7c36f13
+++ cert.hh	c02a471d86e12a1e65436c0f93b76ff9a5268788
@@ -122,7 +122,7 @@ cert_revision_suspended_in_branch(revisi
 void
 cert_revision_suspended_in_branch(revision_id const & ctx,
                         branch_name const & branchname,
-                        app_state & app);
+                        database & db);
 
 void
 cert_revision_date_time(revision_id const & m,
============================================================
--- cmd_db.cc	c8d2b577696e88f1588b56ceb60e4e3a8fea308a
+++ cmd_db.cc	89bba58eaa5389a79297ed1cda4ae6fa9f8d3726
@@ -122,7 +122,7 @@ CMD(db_kill_rev_locally, "kill_rev_local
 
   revision_id revid;
 
-  complete(app, idx(args, 0)(), revid);
+  complete(app.db, idx(args, 0)(), revid);
   N(app.db.revision_exists(revid),
     F("no such revision '%s'") % revid);
 
============================================================
--- cmd_key_cert.cc	88455e8ba65a5f90f31fcadb9649e35725ae477f
+++ cmd_key_cert.cc	54ee3b62be8731cc525c8fc9060f5474cc884e99
@@ -315,8 +315,8 @@ CMD(suspend, "suspend", "", CMD_REF(revi
     throw usage(execid);
 
   revision_id r;
-  complete(app, idx(args, 0)(), r);
-  guess_branch(r, app);
+  complete(app.db, idx(args, 0)(), r);
+  guess_branch(r, app.db);
   N(app.opts.branchname() != "", F("need --branch argument to suspend"));
   app.get_project().suspend_revision_in_branch(r, app.opts.branchname);
 }
============================================================
--- cmd_merging.cc	397e1c8cfbabaa94eb61d17f0e7154eef1e6f2eb
+++ cmd_merging.cc	dfb1096757dbdab93830d992d67e0562f04064eb
@@ -162,7 +162,7 @@ CMD(update, "update", "", CMD_REF(worksp
     {
       P(F("updating along branch '%s'") % app.opts.branchname);
       set<revision_id> candidates;
-      pick_update_candidates(old_rid, app, candidates);
+      pick_update_candidates(old_rid, app.db, candidates);
       N(!candidates.empty(),
         F("your request matches no descendents of the current revision\n"
           "in fact, it doesn't even match the current revision\n"
============================================================
--- cmd_netsync.cc	adda0fbd68bbc375c1e271963fe41bb09077d798
+++ cmd_netsync.cc	1e1d50899fd1bf98e7af49773820a205c195ec8f
@@ -78,7 +78,7 @@ find_key(utf8 const & addr,
     {
       if (needed)
         {
-          get_user_key(key, app);
+          get_user_key(key, app.keys);
         }
     }
   app.opts.signing_key = key;
============================================================
--- database.cc	5c68207981f7599b76d2fcad1f60d9770ed6d709
+++ database.cc	5dea9bcb9b63912a2777d21681a019d0445c010b
@@ -3523,6 +3523,14 @@ database::hook_get_author(rsa_keypair_id
   return __app->lua.hook_get_author(__app->opts.branchname, k, author);
 }
 
+bool
+database::hook_accept_testresult_change(std::map<rsa_keypair_id, bool> const & old_results,
+                                     std::map<rsa_keypair_id, bool> const & new_results)
+{
+  return __app->lua.hook_accept_testresult_change(old_results, new_results);
+}
+
+
 key_store &
 database::get_key_store()
 {
@@ -3548,6 +3556,12 @@ database::get_opt_author()
   return __app->opts.author;
 }
 
+bool const
+database::get_opt_ignore_suspend_certs()
+{
+  return __app->opts.ignore_suspend_certs;
+}
+
 date_t const
 database::get_opt_date_or_cur_date()
 {
============================================================
--- database.hh	4ec4892a81f140da06caf418f89dad9c6ae803d7
+++ database.hh	22a1713bf1f5346faab35220b8846f905e1abfac
@@ -606,6 +606,8 @@ public:
     hexenc<id> const & id, cert_name const & name, cert_value const & val);
   bool hook_get_author(rsa_keypair_id const & k,
                        std::string & author);
+  bool hook_accept_testresult_change(std::map<rsa_keypair_id, bool> const & old_results,
+                                     std::map<rsa_keypair_id, bool> const & new_results);
   bool must_drop_attr(std::string const & key);
 
   utf8 const & get_opt_author();
@@ -613,6 +615,7 @@ public:
   bool has_opt_branch();
   branch_name const & get_opt_branchname();
   bool const get_opt_set_default();
+  bool const get_opt_ignore_suspend_certs();
   void set_opt_branchname(branch_name const & branchname);
 
   key_store & get_key_store();
============================================================
--- project.cc	5cb6f6d5a962d7732d74525d5be972b53b6d67e1
+++ project.cc	7ee05b374c4adb790c8b3b08f0d91bd04c22447a
@@ -97,20 +97,20 @@ namespace
 
   struct suspended_in_branch : public is_failure
   {
-    app_state & app;
+    database & db;
     base64<cert_value > const & branch_encoded;
-    suspended_in_branch(app_state & app,
+    suspended_in_branch(database & db,
                   base64<cert_value> const & branch_encoded)
-      : app(app), branch_encoded(branch_encoded)
+      : db(db), branch_encoded(branch_encoded)
     {}
     virtual bool operator()(revision_id const & rid)
     {
       vector< revision<cert> > certs;
-      app.db.get_revision_certs(rid,
-                                cert_name(suspend_cert_name),
-                                branch_encoded,
-                                certs);
-      erase_bogus_certs(certs, app);
+      db.get_revision_certs(rid,
+                            cert_name(suspend_cert_name),
+                            branch_encoded,
+                            certs);
+      erase_bogus_certs(certs, db);
       return !certs.empty();
     }
   };
@@ -120,7 +120,8 @@ project_t::get_branch_heads(branch_name 
 project_t::get_branch_heads(branch_name const & name, std::set<revision_id> & heads,
                             multimap<revision_id, revision_id> *inverse_graph_cache_ptr)
 {
-  std::pair<branch_name, suspended_indicator> cache_index(name, app.opts.ignore_suspend_certs);
+  std::pair<branch_name, suspended_indicator> cache_index(name,
+    db.get_opt_ignore_suspend_certs());
   std::pair<outdated_indicator, std::set<revision_id> > & branch = branch_heads[cache_index];
   if (branch.first.outdated())
     {
@@ -136,9 +137,9 @@ project_t::get_branch_heads(branch_name 
       not_in_branch p(db, branch_encoded);
       erase_ancestors_and_failures(branch.second, p, db, inverse_graph_cache_ptr);
       
-      if (!app.opts.ignore_suspend_certs)
+      if (!db.get_opt_ignore_suspend_certs())
         {
-          suspended_in_branch s(app, branch_encoded);
+          suspended_in_branch s(db, branch_encoded);
           for(std::set<revision_id>::iterator it = branch.second.begin(); it != branch.second.end(); it++)
             if (s(*it))
               branch.second.erase(*it);
@@ -188,11 +189,11 @@ project_t::revision_is_suspended_in_bran
   encode_base64(cert_value(branch()), branch_encoded);
 
   vector<revision<cert> > certs;
-  app.db.get_revision_certs(id, suspend_cert_name, branch_encoded, certs);
+  db.get_revision_certs(id, suspend_cert_name, branch_encoded, certs);
 
   int num = certs.size();
 
-  erase_bogus_certs(certs, app);
+  erase_bogus_certs(certs, db);
 
   L(FL("found %d (%d valid) %s suspend certs on revision %s")
     % num
@@ -207,7 +208,7 @@ project_t::suspend_revision_in_branch(re
 project_t::suspend_revision_in_branch(revision_id const & id,
                                   branch_name const & branch)
 {
-  cert_revision_suspended_in_branch(id, branch, app);
+  cert_revision_suspended_in_branch(id, branch, db);
 }
 
 
============================================================
--- revision.cc	1712b1a74c33ee04480125d5e1a923770aec2ccb
+++ revision.cc	179d8cabfa40a2ebb1433dae86b2d6fb81a88882
@@ -416,7 +416,7 @@ accumulate_strict_ancestors(revision_id 
 accumulate_strict_ancestors(revision_id const & start,
                             set<revision_id> & all_ancestors,
                             multimap<revision_id, revision_id> const & inverse_graph,
-                            app_state & app,
+                            database & db,
                             rev_height const & min_height)
 {
   typedef multimap<revision_id, revision_id>::const_iterator gi;
@@ -436,7 +436,7 @@ accumulate_strict_ancestors(revision_id 
             {
               // prune if we're below min_height
               rev_height h;
-              app.db.get_rev_height(parent, h);
+              db.get_rev_height(parent, h);
               if (h >= min_height)
                 {
                   all_ancestors.insert(parent);
@@ -449,7 +449,7 @@ accumulate_strict_ancestors(revision_id 
 
 // this call is equivalent to running:
 //   erase(remove_if(candidates.begin(), candidates.end(), p));
-//   erase_ancestors(candidates, app);
+//   erase_ancestors(candidates, db);
 // however, by interleaving the two operations, it can in common cases make
 // many fewer calls to the predicate, which can be a significant speed win.
 
@@ -481,11 +481,11 @@ erase_ancestors_and_failures(std::set<re
   set<revision_id> all_ancestors;
 
   rev_height min_height;
-  app.db.get_rev_height(*candidates.begin(), min_height);
+  db.get_rev_height(*candidates.begin(), min_height);
   for (std::set<revision_id>::const_iterator it = candidates.begin(); it != candidates.end(); it++)
     {
       rev_height h;
-      app.db.get_rev_height(*it, h);
+      db.get_rev_height(*it, h);
       if (h < min_height)
         min_height = h;
     }
@@ -510,7 +510,7 @@ erase_ancestors_and_failures(std::set<re
         }
       // okay, it is good enough that all its ancestors should be
       // eliminated
-      accumulate_strict_ancestors(rid, all_ancestors, *inverse_graph_cache_ptr, app, min_height);
+      accumulate_strict_ancestors(rid, all_ancestors, *inverse_graph_cache_ptr, db, min_height);
     }
 
   // now go and eliminate the ancestors
============================================================
--- update.cc	4c5451ee4e1f2e3e549cff753b88c6d4d47f3934
+++ update.cc	370ff546900209b02ac77b6fe2e9dc3a9ffc1932
@@ -13,10 +13,10 @@
 #include "vector.hh"
 #include "lexical_cast.hh"
 
-#include "app_state.hh"
 #include "database.hh"
 #include "sanity.hh"
 #include "cert.hh"
+#include "project.hh"
 #include "transforms.hh"
 #include "ui.hh"
 #include "update.hh"
@@ -54,10 +54,10 @@ get_test_results_for_revision(revision_i
 static void
 get_test_results_for_revision(revision_id const & id,
                               map<rsa_keypair_id, bool> & results,
-                              app_state & app)
+                              database & db)
 {
   vector< revision<cert> > certs;
-  app.get_project().get_revision_certs_by_name(id, cert_name(testresult_cert_name), certs);
+  db.get_project().get_revision_certs_by_name(id, cert_name(testresult_cert_name), certs);
   for (vector< revision<cert> >::const_iterator i = certs.begin();
        i != certs.end(); ++i)
     {
@@ -80,12 +80,12 @@ acceptable_descendent(branch_name const 
                       revision_id const & base,
                       map<rsa_keypair_id, bool> & base_results,
                       revision_id const & target,
-                      app_state & app)
+                      database & db)
 {
   L(FL("Considering update target %s") % target);
 
   // step 1: check the branch
-  if (!app.get_project().revision_is_in_branch(target, branch))
+  if (!db.get_project().revision_is_in_branch(target, branch))
     {
       L(FL("%s not in branch %s") % target % branch);
       return false;
@@ -93,8 +93,8 @@ acceptable_descendent(branch_name const 
 
   // step 2: check the testresults
   map<rsa_keypair_id, bool> target_results;
-  get_test_results_for_revision(target, target_results, app);
-  if (app.lua.hook_accept_testresult_change(base_results, target_results))
+  get_test_results_for_revision(target, target_results, db);
+  if (db.hook_accept_testresult_change(base_results, target_results))
     {
       L(FL("%s is acceptable update candidate") % target);
       return true;
@@ -110,20 +110,20 @@ namespace
 {
   struct suspended_in_branch : public is_failure
   {
-    app_state & app;
+    database & db;
     base64<cert_value > const & branch_encoded;
-    suspended_in_branch(app_state & app,
+    suspended_in_branch(database & db,
                   base64<cert_value> const & branch_encoded)
-      : app(app), branch_encoded(branch_encoded)
+      : db(db), branch_encoded(branch_encoded)
     {}
     virtual bool operator()(revision_id const & rid)
     {
       vector< revision<cert> > certs;
-      app.db.get_revision_certs(rid,
-                                cert_name(suspend_cert_name),
-                                branch_encoded,
-                                certs);
-      erase_bogus_certs(certs, app);
+      db.get_revision_certs(rid,
+                            cert_name(suspend_cert_name),
+                            branch_encoded,
+                            certs);
+      erase_bogus_certs(certs, db);
       return !certs.empty();
     }
   };
@@ -133,17 +133,17 @@ calculate_update_set(revision_id const &
 static void
 calculate_update_set(revision_id const & base,
                      branch_name const & branch,
-                     app_state & app,
+                     database & db,
                      set<revision_id> & candidates)
 {
   map<rsa_keypair_id, bool> base_results;
-  get_test_results_for_revision(base, base_results, app);
+  get_test_results_for_revision(base, base_results, db);
 
   candidates.clear();
   // we possibly insert base into the candidate set as well; returning a set
   // containing just it means that we are up to date; returning an empty set
   // means that there is no acceptable update.
-  if (acceptable_descendent(branch, base, base_results, base, app))
+  if (acceptable_descendent(branch, base, base_results, base, db))
     candidates.insert(base);
 
   // keep a visited set to avoid repeating work
@@ -151,7 +151,7 @@ calculate_update_set(revision_id const &
   set<revision_id> children;
   vector<revision_id> to_traverse;
 
-  app.db.get_revision_children(base, children);
+  db.get_revision_children(base, children);
   copy(children.begin(), children.end(), back_inserter(to_traverse));
 
   while (!to_traverse.empty())
@@ -165,32 +165,32 @@ calculate_update_set(revision_id const &
       visited.insert(target);
 
       // then, possibly insert this revision as a candidate
-      if (acceptable_descendent(branch, base, base_results, target, app))
+      if (acceptable_descendent(branch, base, base_results, target, db))
         candidates.insert(target);
 
       // and traverse its children as well
-      app.db.get_revision_children(target, children);
+      db.get_revision_children(target, children);
       copy(children.begin(), children.end(), back_inserter(to_traverse));
     }
 
-  erase_ancestors(candidates, app.db);
+  erase_ancestors(candidates, db);
   
   bool have_non_suspended_rev = false;
   
   for (set<revision_id>::const_iterator it = candidates.begin(); it != candidates.end(); it++)
     {
-      if (!app.get_project().revision_is_suspended_in_branch(*it, branch))
+      if (!db.get_project().revision_is_suspended_in_branch(*it, branch))
         {
           have_non_suspended_rev = true;
           break;
         }
     }
-  if (!app.opts.ignore_suspend_certs && have_non_suspended_rev)
+  if (!db.get_opt_ignore_suspend_certs() && have_non_suspended_rev)
     {
       // remove all suspended revisions
       base64<cert_value> branch_encoded;
       encode_base64(cert_value(branch()), branch_encoded);
-      suspended_in_branch s(app, branch_encoded);
+      suspended_in_branch s(db, branch_encoded);
       for(std::set<revision_id>::iterator it = candidates.begin(); it != candidates.end(); it++)
         if (s(*it))
           candidates.erase(*it);
@@ -199,15 +199,16 @@ void pick_update_candidates(revision_id 
 
 
 void pick_update_candidates(revision_id const & base_ident,
-                            app_state & app,
+                            database & db,
                             set<revision_id> & candidates)
 {
-  N(app.opts.branchname() != "",
+  branch_name const & branchname = db.get_opt_branchname();
+  N(branchname() != "",
     F("cannot determine branch for update"));
   I(!null_id(base_ident));
 
-  calculate_update_set(base_ident, app.opts.branchname,
-                       app, candidates);
+  calculate_update_set(base_ident, branchname,
+                       db, candidates);
 }
 
 
============================================================
--- update.hh	3bd04ff46a2287f0d679894af43d4edd89c3707e
+++ update.hh	2dc36b9ef125c3861bf4e45477caf1d29b7daa78
@@ -13,7 +13,7 @@
 #include <set>
 #include "vocab.hh"
 
-class app_state;
+class database;
 
 // this function just encapsulates the (somewhat complex) logic
 // behind picking an update target. the actual updating takes
@@ -25,7 +25,7 @@ void pick_update_candidates(revision_id 
 // revision, then 'candidates' will contain exactly the current revision.
 
 void pick_update_candidates(revision_id const & base_ident,
-                            app_state & app,
+                            database & db,
                             std::set<revision_id> &candidates);
 
 // Local Variables: