#
#
# rename "diff_colorizer.cc"
#     to "colorizer.cc"
# 
# rename "diff_colorizer.hh"
#     to "colorizer.hh"
# 
# patch "Makefile.am"
#  from [ad74b99b817f166a80650aef587a4d65edecd482]
#    to [90fe58f5eb062964cd9843379ad274c555e1a1ac]
# 
# patch "asciik.cc"
#  from [cf946f9a14ad309615704bc960255c50e12b636a]
#    to [bdb2253549ec477bf725e9f5ae43c0fa7dff564f]
# 
# patch "asciik.hh"
#  from [592aa966af256f50be9784bfd01c543f54d3447b]
#    to [3e0dcd90804053a5e558b0ddfa6e5f3dcc462d50]
# 
# patch "cmd_diff_log.cc"
#  from [b60b20a376d9e42648bf20db59a88e2647d795f8]
#    to [224b520a69074838e5f5c239968f00f70fcddc01]
# 
# patch "cmd_files.cc"
#  from [c259141b2dfdf62efb777b1c33e3ba84f10e4ddf]
#    to [949020e1e684e833a4513cbaadfea9f2f14ea0e1]
# 
# patch "cmd_ws_commit.cc"
#  from [66094a27fe835dbad1fbb480bc50a567a150ade9]
#    to [4418425491672a99072bccca08df8e1913a58dff]
# 
# patch "colorizer.cc"
#  from [f99f28b5ee0b6d7b22564028461003d8e047f66e]
#    to [c219975b61f0749de94fd6e9a6491022acbde7e3]
# 
# patch "colorizer.hh"
#  from [fed159794f28d3f7f02e716fdedd024e5d4346d1]
#    to [acac5ffcef7270972ccd94aa0a671ab27c892450]
# 
# patch "diff_output.cc"
#  from [42381dd83f123ec8ed07a4894f3e802de846a2e0]
#    to [5feba63e2aca2f4e036b2b453d4f05ca348cfb6b]
# 
# patch "diff_output.hh"
#  from [47ea2a783e32e6183fe07204e957269cd02c6677]
#    to [168281addd27cdade1dc1320ee4814b28070feb8]
# 
# patch "options_list.hh"
#  from [78f2f099c82e0e175a3aa64c0e44865be32b2a2a]
#    to [47ba29256c11c845bc151512e8bbefb58723841e]
# 
# patch "rev_output.cc"
#  from [a2c70b893b31296917d1a2b974faa1da46c13f1e]
#    to [90f5ca2ff78f91bdf512231482d00a2eee37875b]
# 
# patch "rev_output.hh"
#  from [666dd3ed35e16d8b122b4932c2aad05a21a22e25]
#    to [5879a8268a59545c946583b65f66eda4491b979e]
#
============================================================
--- Makefile.am	ad74b99b817f166a80650aef587a4d65edecd482
+++ Makefile.am	90fe58f5eb062964cd9843379ad274c555e1a1ac
@@ -44,7 +44,7 @@ MOST_SOURCES = 								\
 	botan_pipe_cache.hh						\
 	cache_logger.hh cache_logger.cc					\
 	commands.cc commands.hh $(CMD_SOURCES)				\
-	diff_colorizer.cc diff_colorizer.hh                             \
+	colorizer.cc colorizer.hh					\
 	diff_output.cc diff_output.hh					\
 	lua_hooks.cc lua_hooks.hh 					\
 	transforms.cc transforms.hh					\
============================================================
--- asciik.cc	cf946f9a14ad309615704bc960255c50e12b636a
+++ asciik.cc	bdb2253549ec477bf725e9f5ae43c0fa7dff564f
@@ -135,8 +135,8 @@ static revision_id ghost; // valid but e
 
 static revision_id ghost; // valid but empty revision_id to be used as ghost value
 
-asciik::asciik(ostream & os, size_t min_width)
-  : width(min_width), output(os)
+asciik::asciik(ostream & os, colorizer const & color, size_t min_width)
+  : width(min_width), output(os), color(color)
 {
 }
 
@@ -250,10 +250,13 @@ asciik::draw(size_t const curr_items,
 
   // prints it out
   //TODO convert line/interline/interline2 from ASCII to system charset
-  output << line << "  " << lines[0] << '\n';
-  output << interline << "  " << lines[1] << '\n';
+  output << color.colorize(line, colorizer::log_revision)
+         << "  " << lines[0] << '\n';
+  output << color.colorize(interline, colorizer::log_revision)
+         << "  " << lines[1] << '\n';
   for (int i = 2; i < num_lines; ++i)
-    output << interline2 << "  " << lines[i] << '\n';
+    output << color.colorize(interline2, colorizer::log_revision)
+           << "  " << lines[i] << '\n';
 }
 
 bool
@@ -387,7 +390,7 @@ CMD(asciik, "asciik", "", CMD_REF(debug)
   toposort(db, revs, sorted);
   reverse(sorted.begin(), sorted.end());
 
-  asciik graph(std::cout, 10);
+  asciik graph(std::cout, colorizer(app.opts.colorize), 10);
 
   for (vector<revision_id>::const_iterator rev = sorted.begin();
        rev != sorted.end(); ++rev)
============================================================
--- asciik.hh	592aa966af256f50be9784bfd01c543f54d3447b
+++ asciik.hh	3e0dcd90804053a5e558b0ddfa6e5f3dcc462d50
@@ -11,13 +11,14 @@
 #define __ASCIIK_HH__
 
 #include <set>
+#include "colorizer.hh"
 #include "vector.hh"
 #include "vocab.hh"
 
 class asciik
 {
 public:
-  asciik(std::ostream & os, size_t min_width = 0);
+  asciik(std::ostream & os, colorizer const & color, size_t min_width = 0);
   // Prints an ASCII-k chunk using the given revisions.
   // Multiple lines are supported in annotation (the graph will stretch
   // accordingly); empty newlines at the end will be removed.
@@ -41,6 +42,7 @@ private:
   // internal state
   size_t width;
   std::ostream & output;
+  colorizer const & color;
   std::vector<revision_id> curr_row;
 };
 
============================================================
--- cmd_diff_log.cc	b60b20a376d9e42648bf20db59a88e2647d795f8
+++ cmd_diff_log.cc	224b520a69074838e5f5c239968f00f70fcddc01
@@ -17,7 +17,7 @@
 #include "asciik.hh"
 #include "charset.hh"
 #include "cmd.hh"
-#include "diff_colorizer.hh"
+#include "colorizer.hh"
 #include "diff_output.hh"
 #include "file_io.hh"
 #include "parallel_iter.hh"
@@ -70,7 +70,7 @@ dump_diff(lua_hooks & lua,
           bool external_diff_args_given,
           string external_diff_args,
           string const & encloser,
-          diff_colorizer const & colorizer,
+          colorizer const & colorizer,
           ostream & output)
 {
   if (diff_format == external_diff)
@@ -130,7 +130,7 @@ dump_diffs(lua_hooks & lua,
            bool left_from_db,
            bool right_from_db,
            bool show_encloser,
-           diff_colorizer const & colorizer)
+           colorizer const & colorizer)
 {
   parallel::iter<node_map> i(left_roster.all_nodes(), right_roster.all_nodes());
   while (i.next())
@@ -393,7 +393,7 @@ void dump_header(std::string const & rev
                  roster_t const & old_roster,
                  roster_t const & new_roster,
                  std::ostream & out,
-                 diff_colorizer const & colorizer,
+                 colorizer const & colorizer,
                  bool show_if_empty)
 {
   cset changes;
@@ -406,23 +406,23 @@ void dump_header(std::string const & rev
 
   vector<string> lines;
   split_into_lines(summary(), lines);
-  out << colorizer.colorize("#", diff_colorizer::comment) << "\n";
+  out << colorizer.colorize("#", colorizer::diff_comment) << "\n";
   if (!summary().empty())
     {
-      out << colorizer.colorize(revs, diff_colorizer::comment);
-      out << colorizer.colorize("#", diff_colorizer::comment) << "\n";
+      out << colorizer.colorize(revs, colorizer::diff_comment);
+      out << colorizer.colorize("#", colorizer::diff_comment) << "\n";
 
       for (vector<string>::iterator i = lines.begin();
            i != lines.end(); ++i)
         out << colorizer.colorize(string("# ") + *i,
-                                  diff_colorizer::comment) << "\n";
+                                  colorizer::diff_comment) << "\n";
     }
   else
     {
       out << colorizer.colorize(string("# ") + _("no changes"),
-                                diff_colorizer::comment) << "\n";
+                                colorizer::diff_comment) << "\n";
     }
-  out << colorizer.colorize("#", diff_colorizer::comment) << "\n";
+  out << colorizer.colorize("#", colorizer::diff_comment) << "\n";
 }
 
 CMD(diff, "diff", "di", CMD_REF(informative), N_("[PATH]..."),
@@ -434,7 +434,7 @@ CMD(diff, "diff", "di", CMD_REF(informat
        "between them is given.  If no format is specified, unified is "
        "used by default."),
     options::opts::revision | options::opts::depth | options::opts::exclude |
-    options::opts::diff_options | options::opts::colorize)
+    options::opts::diff_options)
 {
   if (app.opts.external_diff_args_given)
     E(app.opts.diff_format == external_diff, origin::user,
@@ -449,7 +449,7 @@ CMD(diff, "diff", "di", CMD_REF(informat
 
   prepare_diff(app, db, old_roster, new_roster, args, old_from_db, new_from_db, revs);
 
-  diff_colorizer colorizer(app.opts.colorize);
+  colorizer colorizer(app.opts.colorize);
 
   if (!app.opts.without_header)
     {
@@ -492,7 +492,7 @@ CMD_AUTOMATE(content_diff, N_("[FILE [..
                dummy_header);
 
   // never colorize the diff output
-  diff_colorizer colorizer(false);
+  colorizer colorizer(false);
 
   if (app.opts.with_header)
     {
@@ -562,27 +562,27 @@ void
                        rev_cmp> frontier_t;
 
 void
-log_print_rev (app_state &      app,
-               database &       db,
-               project_t &      project,
-               revision_id      rid,
-               revision_t &     rev,
-               string           date_fmt,
-               node_restriction mask,
-               ostream &        out)
+log_print_rev(app_state & app,
+              database & db,
+              project_t const & project,
+              revision_id const & rid,
+              revision_t const & rev,
+              string const & date_fmt,
+              node_restriction const & mask,
+              colorizer const & color,
+              ostream & out)
 {
-  cert_name const author_name(author_cert_name);
-  cert_name const date_name(date_cert_name);
-  cert_name const branch_name(branch_cert_name);
-  cert_name const tag_name(tag_cert_name);
-  cert_name const changelog_name(changelog_cert_name);
-  cert_name const comment_name(comment_cert_name);
   vector<cert> certs;
   project.get_revision_certs(rid, certs);
 
   if (app.opts.brief)
     {
-      out << rid;
+      cert_name const author_name(author_cert_name);
+      cert_name const date_name(date_cert_name);
+      cert_name const branch_name(branch_cert_name);
+
+      out << color.colorize(encode_hexenc(rid.inner()(), rid.inner().made_from),
+                            colorizer::log_revision);
       log_certs(certs, out, author_name);
       if (app.opts.no_graph)
         log_certs(certs, out, date_name, date_fmt);
@@ -597,7 +597,7 @@ log_print_rev (app_state &      app,
   else
     {
       utf8 header;
-      revision_header(rid, rev, certs, date_fmt, header);
+      revision_header(rid, rev, certs, date_fmt, color, header);
 
       external header_external;
       utf8_to_system_best_effort(header, header_external);
@@ -606,7 +606,7 @@ log_print_rev (app_state &      app,
       if (!app.opts.no_files)
         {
           utf8 summary;
-          revision_summary(rev, summary);
+          revision_summary(rev, color, summary);
           external summary_external;
           utf8_to_system_best_effort(summary, summary_external);
           out << summary_external;
@@ -639,16 +639,16 @@ log_print_rev (app_state &      app,
                      app.opts.external_diff_args,
                      true, true,
                      !app.opts.no_show_encloser,
-                     diff_colorizer(app.opts.colorize));
+                     color);
         }
     }
 }
 
 void
-log_common (app_state & app,
-            args_vector args,
-            bool automate,
-            std::ostream & output)
+log_common(app_state & app,
+           args_vector args,
+           bool automate,
+           std::ostream & output)
 {
   database db(app);
   project_t project(db);
@@ -865,8 +865,11 @@ log_common (app_state & app,
 
   set<revision_id> seen;
   revision_t rev;
+
+  colorizer color(app.opts.colorize && !automate);
   // this is instantiated even when not used, but it's lightweight
-  asciik graph(output);
+  asciik graph(output, color);
+
   while(!frontier.empty() && last != 0 && next != 0)
     {
       revision_id const & rid = frontier.top().second;
@@ -962,7 +965,7 @@ log_common (app_state & app,
           else
             {
               ostringstream out;
-              log_print_rev (app, db, project, rid, rev, date_fmt, mask_diff, out);
+              log_print_rev(app, db, project, rid, rev, date_fmt, mask_diff, color, out);
 
               string out_system;
               utf8_to_system_best_effort(utf8(out.str(), origin::internal), out_system);
@@ -1010,9 +1013,9 @@ CMD(log, "log", "", CMD_REF(informative)
     options::opts::brief | options::opts::diffs |
     options::opts::depth | options::opts::exclude |
     options::opts::no_merges | options::opts::no_files |
-    options::opts::no_graph | options::opts::colorize )
+    options::opts::no_graph )
 {
-  log_common (app, args, false, cout);
+  log_common(app, args, false, cout);
 }
 
 CMD_AUTOMATE(log, N_("[PATH] ..."),
@@ -1023,7 +1026,7 @@ CMD_AUTOMATE(log, N_("[PATH] ..."),
     options::opts::depth | options::opts::exclude |
     options::opts::no_merges)
 {
-  log_common (app, args, true, output);
+  log_common(app, args, true, output);
 }
 
 // Local Variables:
============================================================
--- cmd_files.cc	c259141b2dfdf62efb777b1c33e3ba84f10e4ddf
+++ cmd_files.cc	949020e1e684e833a4513cbaadfea9f2f14ea0e1
@@ -14,7 +14,7 @@
 #include "annotate.hh"
 #include "revision.hh"
 #include "cmd.hh"
-#include "diff_colorizer.hh"
+#include "colorizer.hh"
 #include "diff_output.hh"
 #include "merge_content.hh"
 #include "file_io.hh"
@@ -96,7 +96,7 @@ CMD(fdiff, "fdiff", "", CMD_REF(debug), 
 CMD(fdiff, "fdiff", "", CMD_REF(debug), N_("SRCNAME DESTNAME SRCID DESTID"),
     N_("Differences 2 files and outputs the result"),
     "",
-    options::opts::diff_options | options::opts::colorize)
+    options::opts::diff_options)
 {
   if (args.size() != 4)
     throw usage(execid);
@@ -131,7 +131,7 @@ CMD(fdiff, "fdiff", "", CMD_REF(debug), 
             src_id, dst_id,
             src.inner(), dst.inner(),
             cout, app.opts.diff_format, 
-            pattern, diff_colorizer(app.opts.colorize));
+            pattern, colorizer(app.opts.colorize));
 }
 
 CMD(annotate, "annotate", "", CMD_REF(informative), N_("PATH"),
============================================================
--- cmd_ws_commit.cc	66094a27fe835dbad1fbb480bc50a567a150ade9
+++ cmd_ws_commit.cc	4418425491672a99072bccca08df8e1913a58dff
@@ -234,17 +234,20 @@ get_log_message_interactively(lua_hooks 
 
   bool is_date_fmt_valid = date_fmt_valid(date_fmt);
   string null_date_fmt("");
+  colorizer color(false);
 
   if (!is_date_fmt_valid)
     {
       W(F("date format '%s' cannot be used for commit; using default instead") % date_fmt);
-      revision_header(rid, rev, author, date, branch, changelog, null_date_fmt, header);
+      revision_header(rid, rev, author, date, branch, changelog,
+                      null_date_fmt, color, header);
     }
   else
     {
-      revision_header(rid, rev, author, date, branch, changelog, date_fmt, header);
+      revision_header(rid, rev, author, date, branch, changelog,
+                      date_fmt, color, header);
     }
-  revision_summary(rev, summary);
+  revision_summary(rev, color, summary);
 
   utf8 full_message(instructions() + cancel() + header() + notes() + summary(),
                     origin::internal);
@@ -985,10 +988,11 @@ CMD(status, "status", "", CMD_REF(inform
 
   utf8 header;
   utf8 summary;
+  colorizer color(app.opts.colorize);
 
   revision_header(rid, rev, author, date_t::now(), app.opts.branch, changelog,
-                  date_fmt, header);
-  revision_summary(rev, summary);
+                  date_fmt, color, header);
+  revision_summary(rev, color, summary);
 
   external header_external;
   external summary_external;
============================================================
--- diff_colorizer.cc	f99f28b5ee0b6d7b22564028461003d8e047f66e
+++ colorizer.cc	c219975b61f0749de94fd6e9a6491022acbde7e3
@@ -8,33 +8,35 @@
 // PURPOSE.
 
 #include "base.hh"
-#include "diff_colorizer.hh"
+#include "colorizer.hh"
 #include "platform.hh"
 
 using std::string;
 using std::map;
 using std::make_pair;
 
-diff_colorizer::diff_colorizer(bool enable)
+colorizer::colorizer(bool enable)
 {
   if (!have_smart_terminal())
     enable = false;
 
   if (enable)
     {
-      colormap.insert(std::make_pair(normal,   ""));
-      colormap.insert(std::make_pair(bold,     "\033[1m"));
-      colormap.insert(std::make_pair(encloser, "\033[1;34m"));
-      colormap.insert(std::make_pair(add,      "\033[32m"));
-      colormap.insert(std::make_pair(del,      "\033[31m"));
-      colormap.insert(std::make_pair(change,   "\033[33m"));
-      colormap.insert(std::make_pair(comment,  "\033[36m"));
-      colormap.insert(std::make_pair(reset,    "\033[m"));
+      colormap.insert(std::make_pair(normal,         ""));
+      colormap.insert(std::make_pair(reset,          "\033[m"));
+      colormap.insert(std::make_pair(diff_encloser,  "\033[1;34m"));
+      colormap.insert(std::make_pair(diff_add,       "\033[32m"));
+      colormap.insert(std::make_pair(diff_delete,    "\033[31m"));
+      colormap.insert(std::make_pair(diff_change,    "\033[33m"));
+      colormap.insert(std::make_pair(diff_comment,   "\033[36m"));
+      colormap.insert(std::make_pair(diff_separator, "\033[1m"));
+      colormap.insert(std::make_pair(log_revision,   "\033[34m"));
+      colormap.insert(std::make_pair(rev_header,     "\033[1m"));
     }
 }
 
 string
-diff_colorizer::colorize(string const & in, purpose p) const
+colorizer::colorize(string const & in, purpose p) const
 {
   if (colormap.find(p) == colormap.end())
     return in;
============================================================
--- diff_colorizer.hh	fed159794f28d3f7f02e716fdedd024e5d4346d1
+++ colorizer.hh	acac5ffcef7270972ccd94aa0a671ab27c892450
@@ -7,24 +7,27 @@
 // implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 // PURPOSE.
 
-#ifndef __DIFF_COLORIZER_HH__
-#define __DIFF_COLORIZER_HH__
+#ifndef __COLORIZER_HH__
+#define __COLORIZER_HH__
 
 #include "vocab.hh"
 #include <map>
 
-struct diff_colorizer {
+struct colorizer {
 
   typedef enum { normal = 0,
-                 bold,
-                 encloser,
-                 add,
-                 del,
-                 change,
-                 comment,
-                 reset } purpose;
+                 reset,
+                 diff_encloser,
+                 diff_add,
+                 diff_delete,
+                 diff_change,
+                 diff_comment,
+                 diff_separator,
+                 log_revision,
+                 rev_header
+                 } purpose;
 
-  diff_colorizer(bool enable);
+  colorizer(bool enable);
 
   std::string
   colorize(std::string const & in, purpose p = normal) const;
@@ -33,7 +36,7 @@ private:
   std::map<purpose, std::string> colormap;
 };
 
-#endif // __DIFF_COLORIZER_HH__
+#endif // __COLORIZER_HH__
 
 // Local Variables:
 // mode: C++
============================================================
--- diff_output.cc	42381dd83f123ec8ed07a4894f3e802de846a2e0
+++ diff_output.cc	5feba63e2aca2f4e036b2b453d4f05ca348cfb6b
@@ -47,7 +47,7 @@ struct hunk_consumer
   vector<string>::const_reverse_iterator encloser_last_match;
   vector<string>::const_reverse_iterator encloser_last_search;
 
-  diff_colorizer colorizer;
+  colorizer color;
 
   virtual void flush_hunk(size_t pos) = 0;
   virtual void advance_to(size_t newpos) = 0;
@@ -60,11 +60,11 @@ struct hunk_consumer
                 size_t ctx,
                 ostream & ost,
                 string const & encloser_pattern,
-                diff_colorizer const & colorizer)
+                colorizer const & color)
     : a(a), b(b), ctx(ctx), ost(ost), encloser_re(0),
       a_begin(0), b_begin(0), a_len(0), b_len(0), skew(0),
       encloser_last_match(a.rend()), encloser_last_search(a.rend()),
-      colorizer(colorizer)
+      color(color)
   {
     if (encloser_pattern != "")
       encloser_re.reset(new pcre::regex(encloser_pattern, origin::user));
@@ -177,23 +177,23 @@ struct unidiff_hunk_writer : public hunk
                       size_t ctx,
                       ostream & ost,
                       string const & encloser_pattern,
-                      diff_colorizer const & colorizer)
-  : hunk_consumer(a, b, ctx, ost, encloser_pattern, colorizer)
+                      colorizer const & color)
+  : hunk_consumer(a, b, ctx, ost, encloser_pattern, color)
   {}
 };
 
 void unidiff_hunk_writer::insert_at(size_t b_pos)
 {
   b_len++;
-  hunk.push_back(colorizer.colorize(string("+") + b[b_pos],
-                                    diff_colorizer::add));
+  hunk.push_back(color.colorize(string("+") + b[b_pos],
+                                    colorizer::diff_add));
 }
 
 void unidiff_hunk_writer::delete_at(size_t a_pos)
 {
   a_len++;
-  hunk.push_back(colorizer.colorize(string("-") + a[a_pos],
-                                    diff_colorizer::del));
+  hunk.push_back(color.colorize(string("-") + a[a_pos],
+                                    colorizer::diff_delete));
 }
 
 void unidiff_hunk_writer::flush_hunk(size_t pos)
@@ -243,8 +243,8 @@ void unidiff_hunk_writer::flush_hunk(siz
         find_encloser(a_begin + first_mod, encloser);
         ss << " @@";
 
-        ost << colorizer.colorize(ss.str(), diff_colorizer::bold);
-        ost << colorizer.colorize(encloser, diff_colorizer::encloser);
+        ost << color.colorize(ss.str(), colorizer::diff_separator);
+        ost << color.colorize(encloser, colorizer::diff_encloser);
         ost << '\n';
       }
       copy(hunk.begin(), hunk.end(), ostream_iterator<string>(ost, "\n"));
@@ -312,7 +312,7 @@ struct cxtdiff_hunk_writer : public hunk
                       size_t ctx,
                       ostream & ost,
                       string const & encloser_pattern,
-                      diff_colorizer const & colorizer)
+                      colorizer const & colorizer)
   : hunk_consumer(a, b, ctx, ost, encloser_pattern, colorizer),
     have_insertions(false), have_deletions(false)
   {}
@@ -375,8 +375,8 @@ void cxtdiff_hunk_writer::flush_hunk(siz
         find_encloser(a_begin + min(first_insert, first_delete),
                       encloser);
 
-        ost << colorizer.colorize("***************", diff_colorizer::bold)
-            << colorizer.colorize(encloser, diff_colorizer::encloser) << '\n';
+        ost << color.colorize("***************", colorizer::diff_separator)
+            << color.colorize(encloser, colorizer::diff_encloser) << '\n';
       }
 
       ost << "*** " << (a_begin + 1) << ',' << (a_begin + a_len) << " ****\n";
@@ -410,33 +410,33 @@ void cxtdiff_hunk_writer::flush_pending_
 
   // if we have just insertions to flush, prefix them with "+"; if
   // just deletions, prefix with "-"; if both, prefix with "!"
-  diff_colorizer::purpose p = diff_colorizer::normal;
+  colorizer::purpose p = colorizer::normal;
   if (inserts.empty() && !deletes.empty())
   {
     prefix = "-";
-    p = diff_colorizer::del;
+    p = colorizer::diff_delete;
   }
   else if (deletes.empty() && !inserts.empty())
   {
     prefix = "+";
-    p = diff_colorizer::add;
+    p = colorizer::diff_add;
   }
   else
   {
     prefix = "!";
-    p = diff_colorizer::change;
+    p = colorizer::diff_change;
   }
 
   for (vector<size_t>::const_iterator i = deletes.begin();
        i != deletes.end(); ++i)
     {
-      from_file.push_back(colorizer.colorize(prefix + string(" ") + a[*i], p));
+      from_file.push_back(color.colorize(prefix + string(" ") + a[*i], p));
       a_len++;
     }
   for (vector<size_t>::const_iterator i = inserts.begin();
        i != inserts.end(); ++i)
     {
-      to_file.push_back(colorizer.colorize(prefix + string(" ") + b[*i], p));
+      to_file.push_back(color.colorize(prefix + string(" ") + b[*i], p));
       b_len++;
     }
 
@@ -498,12 +498,12 @@ make_diff(string const & filename1,
           ostream & ost,
           diff_type type,
           string const & pattern,
-          diff_colorizer const & colorizer)
+          colorizer const & color)
 {
   if (guess_binary(data1()) || guess_binary(data2()))
     {
-      ost << colorizer.colorize(string("# ") + filename2 + " is binary",
-                                diff_colorizer::comment) << "\n";
+      ost << color.colorize(string("# ") + filename2 + " is binary",
+                            colorizer::diff_comment) << "\n";
       return;
     }
 
@@ -594,25 +594,23 @@ make_diff(string const & filename1,
     {
       case unified_diff:
       {
-        ost << colorizer.colorize(string("--- ") + filename1, diff_colorizer::del)
+        ost << color.colorize(string("--- ") + filename1, colorizer::diff_delete)
             << '\t' << id1 << '\n';
-        ost << colorizer.colorize(string("+++ ") + filename2, diff_colorizer::add)
+        ost << color.colorize(string("+++ ") + filename2, colorizer::diff_add)
             << '\t' << id2 << '\n';
 
-        unidiff_hunk_writer hunks(lines1, lines2, 3, ost,
-                                  pattern, colorizer);
+        unidiff_hunk_writer hunks(lines1, lines2, 3, ost, pattern, color);
         walk_hunk_consumer(lcs, left_interned, right_interned, hunks);
         break;
       }
       case context_diff:
       {
-        ost << colorizer.colorize(string("*** ") + filename1, diff_colorizer::del)
+        ost << color.colorize(string("*** ") + filename1, colorizer::diff_delete)
             << '\t' << id1 << '\n';
-        ost << colorizer.colorize(string("--- ") + filename2, diff_colorizer::add)
+        ost << color.colorize(string("--- ") + filename2, colorizer::diff_add)
             << '\t' << id2 << '\n';
 
-        cxtdiff_hunk_writer hunks(lines1, lines2, 3, ost,
-                                  pattern, colorizer);
+        cxtdiff_hunk_writer hunks(lines1, lines2, 3, ost, pattern, color);
         walk_hunk_consumer(lcs, left_interned, right_interned, hunks);
         break;
       }
============================================================
--- diff_output.hh	47ea2a783e32e6183fe07204e957269cd02c6677
+++ diff_output.hh	168281addd27cdade1dc1320ee4814b28070feb8
@@ -15,7 +15,7 @@
 // of GNU-diffutils-like things (diff, diff3, maybe patch..)
 
 #include "vocab.hh"
-#include "diff_colorizer.hh"
+#include "colorizer.hh"
 
 void make_diff(std::string const & filename1,
                std::string const & filename2,
@@ -26,7 +26,7 @@ void make_diff(std::string const & filen
                std::ostream & ost,
                diff_type type,
                std::string const & pattern,
-               diff_colorizer const & colorizer);
+               colorizer const & colorizer);
 
 #endif // __DIFF_PATCH_HH__
 
============================================================
--- options_list.hh	78f2f099c82e0e175a3aa64c0e44865be32b2a2a
+++ options_list.hh	47ba29256c11c845bc151512e8bbefb58723841e
@@ -244,6 +244,12 @@ GOPT(format_dates, "no-format-dates", bo
 }
 #endif
 
+GOPT(colorize, "colorize", bool, false, gettext_noop("colorize output"))
+#ifdef option_bodies
+{
+    colorize = true;
+}
+#endif
 
 OPTVAR(globals, db_type, dbname_type, );
 OPTVAR(globals, std::string, dbname_alias, );
@@ -370,14 +376,6 @@ OPT(diffs, "diffs", bool, false, gettext
 }
 #endif
 
-
-OPT(colorize, "colorize", bool, false, gettext_noop("colorize diff output"))
-#ifdef option_bodies
-{
-    colorize = true;
-}
-#endif
-
 OPTVAR(drop_attr, std::set<std::string>, attrs_to_drop, )
 OPTION(drop_attr, drop_attr, true, "drop-attr",
         gettext_noop("when rosterifying, drop attrs entries with the given key"))
============================================================
--- rev_output.cc	a2c70b893b31296917d1a2b974faa1da46c13f1e
+++ rev_output.cc	90f5ca2ff78f91bdf512231482d00a2eee37875b
@@ -31,40 +31,40 @@ revision_header(revision_id const rid, r
 revision_header(revision_id const rid, revision_t const & rev,
                 string const & author, date_t const date,
                 branch_name const & branch, utf8 const & changelog,
-                string const & date_fmt, utf8 & header)
+                string const & date_fmt, colorizer const & color, utf8 & header)
 {
   vector<cert> certs;
   key_id empty_key;
-  certs.push_back(cert(rid, author_cert_name, 
+  certs.push_back(cert(rid, author_cert_name,
                        cert_value(author, origin::user), empty_key));
-  certs.push_back(cert(rid, date_cert_name, 
+  certs.push_back(cert(rid, date_cert_name,
                        cert_value(date.as_iso_8601_extended(), origin::user),
                        empty_key));
-  certs.push_back(cert(rid, branch_cert_name, 
+  certs.push_back(cert(rid, branch_cert_name,
                        cert_value(branch(), origin::user), empty_key));
 
   if (!changelog().empty())
-    certs.push_back(cert(rid, changelog_cert_name, 
+    certs.push_back(cert(rid, changelog_cert_name,
                          cert_value(changelog(), origin::user), empty_key));
 
-  revision_header(rid, rev, certs, date_fmt, header);
+  revision_header(rid, rev, certs, date_fmt, color, header);
 }
 
 void
 revision_header(revision_id const rid, revision_t const & rev,
                 vector<cert> const & certs, string const & date_fmt,
-                utf8 & header)
+                colorizer const & color, utf8 & header)
 {
   ostringstream out;
 
-  out << string(70, '-') << '\n'
-      << _("Revision: ") << rid << '\n';
+  out << color.colorize(string(70, '-'), colorizer::log_revision) << '\n'
+      << color.colorize(_("Revision: "), colorizer::rev_header) << rid << '\n';
 
   for (edge_map::const_iterator i = rev.edges.begin(); i != rev.edges.end(); ++i)
     {
       revision_id parent = edge_old_revision(*i);
       if (!null_id(parent))
-        out << _("Parent:   ") << parent << '\n';
+        out << color.colorize(_("Parent:   "), colorizer::rev_header) << parent << '\n';
     }
 
   cert_name const author(author_cert_name);
@@ -76,34 +76,40 @@ revision_header(revision_id const rid, r
 
   for (vector<cert>::const_iterator i = certs.begin(); i != certs.end(); ++i)
     if (i->name == author)
-      out << _("Author:   ") << i->value << '\n';
+      out << color.colorize(_("Author:   "), colorizer::rev_header)
+          << i->value << '\n';
 
   for (vector<cert>::const_iterator i = certs.begin(); i != certs.end(); ++i)
     if (i->name == date)
       {
         if (date_fmt.empty())
-          out << _("Date:     ") << i->value << '\n';
+          out << color.colorize(_("Date:     "), colorizer::rev_header)
+              << i->value << '\n';
         else
           {
             date_t date(i->value());
-            out << _("Date:     ") << date.as_formatted_localtime(date_fmt) << '\n';
+            out << color.colorize(_("Date:     "), colorizer::rev_header)
+                << date.as_formatted_localtime(date_fmt) << '\n';
           }
       }
 
   for (vector<cert>::const_iterator i = certs.begin(); i != certs.end(); ++i)
     if (i->name == branch)
-      out << _("Branch:   ") << i->value << '\n';
+      out << color.colorize(_("Branch:   "), colorizer::rev_header)
+          << i->value << '\n';
 
   for (vector<cert>::const_iterator i = certs.begin(); i != certs.end(); ++i)
     if (i->name == tag)
-      out << _("Tag:      ") << i->value << '\n';
+      out << color.colorize(_("Tag:      "), colorizer::rev_header)
+          << i->value << '\n';
 
   out << "\n";
 
   for (vector<cert>::const_iterator i = certs.begin(); i != certs.end(); ++i)
     if (i->name == changelog)
       {
-        out << _("Changelog: ") << "\n\n" << i->value << '\n';
+        out << color.colorize(_("Changelog: "), colorizer::rev_header) << "\n\n"
+            << i->value << '\n';
         if (!i->value().empty() && i->value()[i->value().length()-1] != '\n')
           out << '\n';
       }
@@ -111,7 +117,8 @@ revision_header(revision_id const rid, r
   for (vector<cert>::const_iterator i = certs.begin(); i != certs.end(); ++i)
     if (i->name == comment)
       {
-        out << _("Comments: ") << "\n\n" << i->value << '\n';
+        out << color.colorize(_("Comments: "), colorizer::rev_header) << "\n\n"
+            << i->value << '\n';
         if (!i->value().empty() && i->value()[i->value().length()-1] != '\n')
           out << '\n';
       }
@@ -120,7 +127,7 @@ void
 }
 
 void
-revision_summary(revision_t const & rev, utf8 & summary)
+revision_summary(revision_t const & rev, colorizer const & color, utf8 & summary)
 {
   // We intentionally do not collapse the final \n into the format
   // strings here, for consistency with newline conventions used by most
@@ -138,9 +145,9 @@ revision_summary(revision_t const & rev,
       // A colon at the end of this string looked nicer, but it made
       // double-click copying from terminals annoying.
       if (null_id(parent))
-        out << _("Changes") << "\n\n";
+        out << color.colorize(_("Changes"), colorizer::rev_header) << "\n\n";
       else
-        out << _("Changes against parent ") << parent << "\n\n";
+        out << color.colorize(_("Changes against parent "), colorizer::rev_header) << parent << "\n\n";
 
       // presumably a merge rev could have an empty edge if one side won
       if (cs.empty())
@@ -179,7 +186,7 @@ revision_summary(revision_t const & rev,
       // the cset calls it attrs_cleared
       // the command is attr drop
       // here it is called unset
-      // the revision text uses attr clear 
+      // the revision text uses attr clear
 
       for (set<pair<file_path, attr_key> >::const_iterator
              i = cs.attrs_cleared.begin(); i != cs.attrs_cleared.end(); ++i)
============================================================
--- rev_output.hh	666dd3ed35e16d8b122b4932c2aad05a21a22e25
+++ rev_output.hh	5879a8268a59545c946583b65f66eda4491b979e
@@ -10,6 +10,7 @@
 #ifndef __REV_SUMMARY_HH__
 #define __REV_SUMMARY_HH__
 
+#include "colorizer.hh"
 #include "rev_types.hh"
 #include "vocab.hh"
 
@@ -17,18 +18,19 @@ void
 struct cert;
 
 void
-revision_header(revision_id const rid, revision_t const & rev, 
+revision_header(revision_id const rid, revision_t const & rev,
                 std::string const & author, date_t const date,
                 branch_name const & branch, utf8 const & changelog,
-                std::string const & date_fmt, utf8 & header);
+                std::string const & date_fmt, colorizer const & color,
+                utf8 & header);
 
 void
-revision_header(revision_id const rid, revision_t const & rev, 
+revision_header(revision_id const rid, revision_t const & rev,
                 std::vector<cert> const & certs, std::string const & date_fmt,
-                utf8 & header);
+                colorizer const & color, utf8 & header);
 
 void
-revision_summary(revision_t const & rev, utf8 & summary);
+revision_summary(revision_t const & rev, colorizer const & color, utf8 & summary);
 
 #endif  // header guard