#
#
# patch "README.encapsulation"
#  from [c67fabf6f33cb4b8790f4a08d6eed3fc975336c7]
#    to [e2aef6a23dd4e3a6b85d97016639544a45fa8946]
# 
# patch "asciik.cc"
#  from [d5f28c70d0433dec7d0db7e1f035ea8a12ebbdd2]
#    to [e52020dbc9cabe05bbca08e996f90b02a0fed7bf]
# 
# patch "automate.cc"
#  from [ee573f26aa839258423b024608db769f87f02483]
#    to [0dc786ba3096b88f2c77da34e37283a48effda27]
# 
# patch "cmd_db.cc"
#  from [a897d7dfbaa499adc2c8279d0f051eaa30f4e635]
#    to [3337e33c3e7dab3bd3e20a62b6f669549e188699]
# 
# patch "cmd_diff_log.cc"
#  from [1b7f8c23e25beaa81669eefb504de8315b7fbd4d]
#    to [489b808e2b1944053769838376b50c4ee6377c72]
# 
# patch "cmd_merging.cc"
#  from [af61f02853172ea7a6c53cee6579c0220766d53d]
#    to [0d8932c108698850bff26d77eee7281f18a4908e]
# 
# patch "diff_patch.cc"
#  from [5437f74550a59622f0aca36b00dd43f104b7692a]
#    to [bd3f82e6aaebc8adf4be31db6efa17988a8a29c0]
# 
# patch "legacy.cc"
#  from [6867f219f457fa5df90b2801871c1e1f61a451f0]
#    to [c5282851d756be77cd0c9650a5a478830bd7f80c]
# 
# patch "legacy.hh"
#  from [158f7db6cbe333fe695d3a8dcd335ad0abc47e7d]
#    to [a9f39bf43f05328c63ea616b8fcfb6ac23042271]
# 
# patch "project.cc"
#  from [f64755c9f3508c82ba5717115171d2ac657b6f5c]
#    to [8f68f4af163a87d49ff95870e00f579f9e3212c4]
# 
# patch "revision.cc"
#  from [94ffffda8ea5623d05fef8d062b2a4401599578d]
#    to [d913e67ae0e33d090d98bab4998c46678f20f753]
# 
# patch "revision.hh"
#  from [5f873cb70641d7a40d9e17a897f318ab8f34026c]
#    to [1c26954528febd8f966a7a9d1202cc60affc0d5f]
# 
# patch "update.cc"
#  from [e5fa61130ca338a4a9f4aff804b50e0e23e748f2]
#    to [c90d0e57889ba1b4e3c47a71a9f29cfc512d1bc6]
#
============================================================
--- README.encapsulation	c67fabf6f33cb4b8790f4a08d6eed3fc975336c7
+++ README.encapsulation	e2aef6a23dd4e3a6b85d97016639544a45fa8946
@@ -7,3 +7,34 @@ annotate.cc:
     app.get_project().get_revision_certs(*i, certs);
 
     needs: erase_bogus_certs()
+
+
+revision.cc:
+
+  struct anc_graph still uses app_state, while most methods only need the
+  database, these functions are exceptions:
+
+    anc_graph::write_certs():
+      needs: make_simple_cert()
+
+    anc_graph::add_node_for_old_manifest
+      needs: erase_bogus_cert()
+
+    anc_graph::construct_revisions_from_ancestry()
+      app.opts.attrs_to_drop
+
+
+  build_roster_style_revs_from_manifest_style_revs()
+
+    app.db....
+    needs: anc_graph()
+    needs: get_user_key()
+    needs: require_password()
+
+
+  build_changesets_from_manifest_ancestry()
+    app.db...
+    needs: anc_graph()
+    needs: get_user_key()
+    needs: require_password()
+    needs: erase_bogus_certs()
============================================================
--- asciik.cc	d5f28c70d0433dec7d0db7e1f035ea8a12ebbdd2
+++ asciik.cc	e52020dbc9cabe05bbca08e996f90b02a0fed7bf
@@ -389,7 +389,7 @@ CMD(asciik, N_("debug"), N_("SELECTOR"),
       revs.insert(rid);
     }
   vector<revision_id> sorted;
-  toposort(revs, sorted, app);
+  toposort(revs, sorted, app.db);
   vector<revision_id> curr_row;
   reverse(sorted.begin(), sorted.end());
   for (vector<revision_id>::const_iterator rev = sorted.begin();
============================================================
--- automate.cc	ee573f26aa839258423b024608db769f87f02483
+++ automate.cc	0dc786ba3096b88f2c77da34e37283a48effda27
@@ -189,7 +189,7 @@ AUTOMATE(erase_ancestors, N_("[REV1 [REV
       N(app.db.revision_exists(rid), F("No such revision %s") % rid);
       revs.insert(rid);
     }
-  erase_ancestors(revs, app);
+  erase_ancestors(revs, app.db);
   for (set<revision_id>::const_iterator i = revs.begin(); i != revs.end(); ++i)
     output << (*i).inner()() << '\n';
 }
@@ -336,7 +336,7 @@ AUTOMATE(toposort, N_("[REV1 [REV2 [REV3
       revs.insert(rid);
     }
   vector<revision_id> sorted;
-  toposort(revs, sorted, app);
+  toposort(revs, sorted, app.db);
   for (vector<revision_id>::const_iterator i = sorted.begin();
        i != sorted.end(); ++i)
     output << (*i).inner()() << '\n';
@@ -375,10 +375,10 @@ AUTOMATE(ancestry_difference, N_("NEW_RE
       bs.insert(b);
     }
   set<revision_id> ancestors;
-  ancestry_difference(a, bs, ancestors, app);
+  ancestry_difference(a, bs, ancestors, app.db);
 
   vector<revision_id> sorted;
-  toposort(ancestors, sorted, app);
+  toposort(ancestors, sorted, app.db);
   for (vector<revision_id>::const_iterator i = sorted.begin();
        i != sorted.end(); ++i)
     output << (*i).inner()() << '\n';
============================================================
--- cmd_db.cc	a897d7dfbaa499adc2c8279d0f051eaa30f4e635
+++ cmd_db.cc	3337e33c3e7dab3bd3e20a62b6f669549e188699
@@ -85,7 +85,7 @@ CMD(db, N_("database"),
       else if (idx(args, 0)() == "rosterify")
         build_roster_style_revs_from_manifest_style_revs(app);
       else if (idx(args, 0)() == "regenerate_caches")
-        regenerate_caches(app);
+        regenerate_caches(app.db);
       else
         throw usage(name);
     }
============================================================
--- cmd_diff_log.cc	1b7f8c23e25beaa81669eefb504de8315b7fbd4d
+++ cmd_diff_log.cc	489b808e2b1944053769838376b50c4ee6377c72
@@ -799,7 +799,7 @@ CMD(log, N_("informative"), N_("[FILE] .
               set<node_id> nodes_modified;
               select_nodes_modified_by_rev(rev, roster,
                                            nodes_modified,
-                                           app);
+                                           app.db);
 
               for (set<node_id>::const_iterator n = nodes_modified.begin();
                    n != nodes_modified.end(); ++n)
============================================================
--- cmd_merging.cc	af61f02853172ea7a6c53cee6579c0220766d53d
+++ cmd_merging.cc	0d8932c108698850bff26d77eee7281f18a4908e
@@ -386,7 +386,7 @@ CMD(merge, N_("tree"), "", N_("merge unm
               continue;
 
             revision_id ancestor;
-            find_common_ancestor_for_merge(*i, *j, ancestor, app);
+            find_common_ancestor_for_merge(*i, *j, ancestor, app.db);
             
             // More than one pair might have the same ancestor (e.g. if we
             // have three heads all with the same parent); as this table
@@ -399,7 +399,7 @@ CMD(merge, N_("tree"), "", N_("merge unm
       // Erasing ancestors from ANCESTORS will now produce a set of merge
       // ancestors each of which is not itself an ancestor of any other
       // merge ancestor.
-      erase_ancestors(ancestors, app);
+      erase_ancestors(ancestors, app.db);
       I(ancestors.size() > 0);
 
       // Take the first ancestor from the above set and merge its
@@ -492,13 +492,13 @@ CMD(merge_into_dir, N_("tree"), N_("SOUR
   P(F("[target] %s") % *dst_i);
 
   // check for special cases
-  if (*src_i == *dst_i || is_ancestor(*src_i, *dst_i, app))
+  if (*src_i == *dst_i || is_ancestor(*src_i, *dst_i, app.db))
     {
       P(F("branch '%s' is up-to-date with respect to branch '%s'")
           % idx(args, 1)() % idx(args, 0)());
       P(F("no action taken"));
     }
-  else if (is_ancestor(*dst_i, *src_i, app))
+  else if (is_ancestor(*dst_i, *src_i, app.db))
     {
       P(F("no merge necessary; putting %s in branch '%s'")
         % (*src_i) % idx(args, 1)());
@@ -651,7 +651,7 @@ CMD(merge_into_workspace, N_("tree"),
 
   revision_id lca_id;
   database::cached_roster lca;
-  find_common_ancestor_for_merge(left_id, right_id, lca_id, app);
+  find_common_ancestor_for_merge(left_id, right_id, lca_id, app.db);
   app.db.get_roster(lca_id, lca);
 
   map<file_id, file_path> paths;
@@ -706,9 +706,9 @@ CMD(explicit_merge, N_("tree"),
 
   N(!(left == right),
     F("%s and %s are the same revision, aborting") % left % right);
-  N(!is_ancestor(left, right, app),
+  N(!is_ancestor(left, right, app.db),
     F("%s is already an ancestor of %s") % left % right);
-  N(!is_ancestor(right, left, app),
+  N(!is_ancestor(right, left, app.db),
     F("%s is already an ancestor of %s") % right % left);
 
   merge_two(left, right, branch, string("explicit merge"), app);
@@ -724,9 +724,9 @@ CMD(show_conflicts, N_("informative"), N
   revision_id l_id, r_id;
   complete(app, idx(args,0)(), l_id);
   complete(app, idx(args,1)(), r_id);                                                                    
-  N(!is_ancestor(l_id, r_id, app),
+  N(!is_ancestor(l_id, r_id, app.db),
     F("%s is an ancestor of %s; no merge is needed.") % l_id % r_id);
-  N(!is_ancestor(r_id, l_id, app),
+  N(!is_ancestor(r_id, l_id, app.db),
     F("%s is an ancestor of %s; no merge is needed.") % r_id % l_id);
   roster_t l_roster, r_roster;
   marking_map l_marking, r_marking;
============================================================
--- diff_patch.cc	5437f74550a59622f0aca36b00dd43f104b7692a
+++ diff_patch.cc	bd3f82e6aaebc8adf4be31db6efa17988a8a29c0
@@ -492,7 +492,7 @@ content_merge_database_adaptor::content_
   // FIXME: possibly refactor to run this lazily, as we don't
   // need to find common ancestors if we're never actually
   // called on to do content merging.
-  find_common_ancestor_for_merge(left, right, lca, app);
+  find_common_ancestor_for_merge(left, right, lca, app.db);
 }
 
 void
============================================================
--- legacy.cc	6867f219f457fa5df90b2801871c1e1f61a451f0
+++ legacy.cc	c5282851d756be77cd0c9650a5a478830bd7f80c
@@ -9,8 +9,8 @@
 
 #include "legacy.hh"
 #include "basic_io.hh"
-#include "app_state.hh"
 #include "constants.hh"
+#include "database.hh"
 
 using std::make_pair;
 using std::string;
@@ -123,13 +123,13 @@ namespace legacy
 
   // cf. revision.cc:parse_revision in the pre-roster code.
   void
-  get_manifest_and_renames_for_rev(app_state & app,
+  get_manifest_and_renames_for_rev(database & db,
                                    revision_id const & ident,
                                    manifest_id & mid,
                                    renames_map & renames)
   {
     revision_data dat;
-    app.db.get_revision(ident, dat);
+    db.get_revision(ident, dat);
     basic_io::input_source src(dat.inner()(), "revision");
     basic_io::tokenizer tok(src);
     basic_io::parser pars(tok);
============================================================
--- legacy.hh	158f7db6cbe333fe695d3a8dcd335ad0abc47e7d
+++ legacy.hh	a9f39bf43f05328c63ea616b8fcfb6ac23042271
@@ -17,7 +17,7 @@
 
 #include "paths.hh"
 
-class app_state;
+class database;
 
 namespace legacy
 {
@@ -41,7 +41,7 @@ namespace legacy
   typedef std::map<revision_id, std::map<split_path, split_path> > renames_map;
 
   void
-  get_manifest_and_renames_for_rev(app_state & app,
+  get_manifest_and_renames_for_rev(database & db,
                                    revision_id const & ident,
                                    manifest_id & mid,
                                    renames_map & renames);
============================================================
--- project.cc	f64755c9f3508c82ba5717115171d2ac657b6f5c
+++ project.cc	8f68f4af163a87d49ff95870e00f579f9e3212c4
@@ -88,7 +88,7 @@ project_t::get_branch_heads(branch_name 
                                                     branch.second);
 
       not_in_branch p(app, branch_encoded);
-      erase_ancestors_and_failures(branch.second, p, app);
+      erase_ancestors_and_failures(branch.second, p, app.db);
       L(FL("found heads of branch %s (%s heads)")
         % name % branch.second.size());
     }
============================================================
--- revision.cc	94ffffda8ea5623d05fef8d062b2a4401599578d
+++ revision.cc	d913e67ae0e33d090d98bab4998c46678f20f753
@@ -177,7 +177,7 @@ find_common_ancestor_for_merge(revision_
 find_common_ancestor_for_merge(revision_id const & left,
                                revision_id const & right,
                                revision_id & anc,
-                               app_state & app)
+                               database & db)
 {
   interner<ctx> intern;
   set<ctx> leaves;
@@ -193,7 +193,7 @@ find_common_ancestor_for_merge(revision_
   multimap<revision_id, revision_id> inverse_graph;
   {
     multimap<revision_id, revision_id> graph;
-    app.db.get_revision_ancestry(graph);
+    db.get_revision_ancestry(graph);
     typedef multimap<revision_id, revision_id>::const_iterator gi;
     for (gi i = graph.begin(); i != graph.end(); ++i)
       inverse_graph.insert(make_pair(i->second, i->first));
@@ -303,12 +303,12 @@ is_ancestor(revision_id const & ancestor
 bool
 is_ancestor(revision_id const & ancestor_id,
             revision_id const & descendent_id,
-            app_state & app)
+            database & db)
 {
   L(FL("checking whether %s is an ancestor of %s") % ancestor_id % descendent_id);
 
   multimap<revision_id, revision_id> graph;
-  app.db.get_revision_ancestry(graph);
+  db.get_revision_ancestry(graph);
   return is_ancestor(ancestor_id, descendent_id, graph);
 }
 
@@ -391,7 +391,7 @@ toposort(set<revision_id> const & revisi
 void
 toposort(set<revision_id> const & revisions,
          vector<revision_id> & sorted,
-         app_state & app)
+         database & db)
 {
   map<rev_height, revision_id> work;
 
@@ -399,7 +399,7 @@ toposort(set<revision_id> const & revisi
        i != revisions.end(); ++i) 
     {
       rev_height height;
-      app.db.get_rev_height(*i, height);
+      db.get_rev_height(*i, height);
       work.insert(make_pair(height, *i));
     }
 
@@ -456,14 +456,14 @@ erase_ancestors_and_failures(std::set<re
 void
 erase_ancestors_and_failures(std::set<revision_id> & candidates,
                              is_failure & p,
-                             app_state & app)
+                             database & db)
 {
   // Load up the ancestry graph
   multimap<revision_id, revision_id> inverse_graph;
   
   {
     multimap<revision_id, revision_id> graph;
-    app.db.get_revision_ancestry(graph);
+    db.get_revision_ancestry(graph);
     for (multimap<revision_id, revision_id>::const_iterator i = graph.begin();
          i != graph.end(); ++i)
       inverse_graph.insert(make_pair(i->second, i->first));
@@ -519,10 +519,10 @@ void
   };
 }
 void
-erase_ancestors(set<revision_id> & revisions, app_state & app)
+erase_ancestors(set<revision_id> & revisions, database & db)
 {
   no_failures p;
-  erase_ancestors_and_failures(revisions, p, app);
+  erase_ancestors_and_failures(revisions, p, db);
 }
 
 // This function takes a revision A and a set of revision Bs, calculates the
@@ -533,14 +533,14 @@ ancestry_difference(revision_id const & 
 void
 ancestry_difference(revision_id const & a, set<revision_id> const & bs,
                     set<revision_id> & new_stuff,
-                    app_state & app)
+                    database & db)
 {
   new_stuff.clear();
   typedef multimap<revision_id, revision_id>::const_iterator gi;
   multimap<revision_id, revision_id> graph;
   multimap<revision_id, revision_id> inverse_graph;
 
-  app.db.get_revision_ancestry(graph);
+  db.get_revision_ancestry(graph);
   for (gi i = graph.begin(); i != graph.end(); ++i)
     inverse_graph.insert(make_pair(i->second, i->first));
 
@@ -588,7 +588,7 @@ select_nodes_modified_by_rev(revision_t 
 select_nodes_modified_by_rev(revision_t const & rev,
                              roster_t const new_roster,
                              set<node_id> & nodes_modified,
-                             app_state & app)
+                             database & db)
 {
   nodes_modified.clear();
 
@@ -597,7 +597,7 @@ select_nodes_modified_by_rev(revision_t 
     {
       set<node_id> edge_nodes_modified;
       roster_t old_roster;
-      app.db.get_roster(edge_old_revision(i), old_roster);
+      db.get_roster(edge_old_revision(i), old_roster);
       select_nodes_modified_by_cset(edge_changes(i),
                                     old_roster,
                                     new_roster,
@@ -1075,7 +1075,7 @@ u64 anc_graph::add_node_for_oldstyle_rev
 
       manifest_id man;
       legacy::renames_map renames;
-      legacy::get_manifest_and_renames_for_rev(app, rev, man, renames);
+      legacy::get_manifest_and_renames_for_rev(app.db, rev, man, renames);
 
       L(FL("node %d = revision %s = manifest %s") % node % rev % man);
       old_rev_to_node.insert(make_pair(rev, node));
@@ -1731,7 +1731,7 @@ allrevs_toposorted(vector<revision_id> &
 // For all other purposes, use toposort above.
 static void
 allrevs_toposorted(vector<revision_id> & revisions,
-                   app_state & app)
+                   database & db)
 {
 
   typedef multimap<revision_id, revision_id>::const_iterator gi;
@@ -1741,7 +1741,7 @@ allrevs_toposorted(vector<revision_id> &
 
   // get the complete ancestry
   multimap<revision_id, revision_id> graph;
-  app.db.get_revision_ancestry(graph);
+  db.get_revision_ancestry(graph);
 
   // determine the number of parents for each rev
   map<revision_id, int> pcount;
@@ -1771,19 +1771,19 @@ void
 }
 
 void
-regenerate_caches(app_state & app)
+regenerate_caches(database & db)
 {
   P(F("regenerating cached rosters and heights"));
 
-  app.db.ensure_open_for_format_changes();
+  db.ensure_open_for_format_changes();
 
-  transaction_guard guard(app.db);
+  transaction_guard guard(db);
 
-  app.db.delete_existing_rosters();
-  app.db.delete_existing_heights();
+  db.delete_existing_rosters();
+  db.delete_existing_heights();
 
   vector<revision_id> sorted_ids;
-  allrevs_toposorted(sorted_ids, app);
+  allrevs_toposorted(sorted_ids, db);
 
   ticker done(_("regenerated"), "r", 5);
   done.set_total(sorted_ids.size());
@@ -1793,9 +1793,9 @@ regenerate_caches(app_state & app)
     {
       revision_t rev;
       revision_id const & rev_id = *i;
-      app.db.get_revision(rev_id, rev);
-      app.db.put_roster_for_revision(rev_id, rev);
-      app.db.put_height_for_revision(rev_id, rev);
+      db.get_revision(rev_id, rev);
+      db.put_roster_for_revision(rev_id, rev);
+      db.put_height_for_revision(rev_id, rev);
       ++done;
     }
 
============================================================
--- revision.hh	5f873cb70641d7a40d9e17a897f318ab8f34026c
+++ revision.hh	1c26954528febd8f966a7a9d1202cc60affc0d5f
@@ -127,20 +127,20 @@ find_common_ancestor_for_merge(revision_
 find_common_ancestor_for_merge(revision_id const & left,
                                revision_id const & right,
                                revision_id & anc,
-                               app_state & app);
+                               database & db);
 
 bool
 is_ancestor(revision_id const & ancestor,
             revision_id const & descendent,
-            app_state & app);
+            database & db);
 
 void
 toposort(std::set<revision_id> const & revisions,
          std::vector<revision_id> & sorted,
-         app_state & app);
+         database & db);
 
 void
-erase_ancestors(std::set<revision_id> & revisions, app_state & app);
+erase_ancestors(std::set<revision_id> & revisions, database & db);
 
 struct is_failure
 {
@@ -150,12 +150,12 @@ erase_ancestors_and_failures(std::set<re
 void
 erase_ancestors_and_failures(std::set<revision_id> & revisions,
                              is_failure & p,
-                             app_state & app);
+                             database & db);
 
 void
 ancestry_difference(revision_id const & a, std::set<revision_id> const & bs,
                     std::set<revision_id> & new_stuff,
-                    app_state & app);
+                    database & db);
 
 
 // FIXME: can probably optimize this passing a lookaside cache of the active
@@ -164,7 +164,7 @@ select_nodes_modified_by_rev(revision_t 
 select_nodes_modified_by_rev(revision_t const & rev,
                              roster_t const roster,
                              std::set<node_id> & nodes_modified,
-                             app_state & app);
+                             database & db);
 
 void
 make_revision(revision_id const & old_rev_id,
@@ -225,7 +225,7 @@ void
 build_roster_style_revs_from_manifest_style_revs(app_state & app);
 
 void
-regenerate_caches(app_state & app);
+regenerate_caches(database & db);
 
 // basic_io access to printers and parsers
 
============================================================
--- update.cc	e5fa61130ca338a4a9f4aff804b50e0e23e748f2
+++ update.cc	c90d0e57889ba1b4e3c47a71a9f29cfc512d1bc6
@@ -148,7 +148,7 @@ calculate_update_set(revision_id const &
       copy(children.begin(), children.end(), back_inserter(to_traverse));
     }
 
-  erase_ancestors(candidates, app);
+  erase_ancestors(candidates, app.db);
 }