Merge lp:~thomas-voss/biometryd/restructure-cli into lp:biometryd

[Thomas Voß]

Alter cli::* interface and provide a cli::Command::Context to run invocations.
Restructure setup of default help options and commands.

Alter cli::* interface and provide a cli::Command::Context to run invocations.
Restructure setup of default help options and commands.

=== modified file 'src/biometry/CMakeLists.txt'
--- src/biometry/CMakeLists.txt	2016-05-09 14:37:52 +0000
+++ src/biometry/CMakeLists.txt	2016-05-10 11:29:00 +0000
@@ -37,8 +37,6 @@
   cmds/identify.cpp
   cmds/list_devices.h
   cmds/list_devices.cpp
-  cmds/help.h
-  cmds/help.cpp
   cmds/run.h
   cmds/run.cpp
   cmds/version.h

=== modified file 'src/biometry/cmds/enroll.cpp'
--- src/biometry/cmds/enroll.cpp	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/enroll.cpp	2016-05-10 11:29:00 +0000
@@ -35,26 +35,18 @@
 namespace cli = biometry::util::cli;
 
 biometry::cmds::Enroll::Enroll()
-    : Command
-      {
-          {
-              Name{"enroll"},
-              Usage{"enroll"},
-              Description{"enrolls a new template to a device"},
-              {}
-          }
-      },
+    : CommandWithFlagsAndAction{cli::Name{"enroll"}, cli::Usage{"enroll"}, cli::Description{"enrolls a new template to a device"}},
       user(biometry::User::current())
 {
-    mutable_info().flags.push_back(cli::make_flag(Name{"device"}, Description{"The device to enroll to"}, device));
-    mutable_info().flags.push_back(cli::make_flag(Name{"device"}, Description{"The device to enroll to"}, device));
-    mutable_info().flags.push_back(cli::make_flag(Name{"user"}, Description{"The user to enroll for"}, device));
+    flag(cli::make_flag(cli::Name{"device"}, cli::Description{"The device to enroll to"}, device));
+    flag(cli::make_flag(cli::Name{"device"}, cli::Description{"The device to enroll to"}, device));
+    flag(cli::make_flag(cli::Name{"user"}, cli::Description{"The user to enroll for"}, device));
 
-    mutable_run() = [this]()
+    action([this](const cli::Command::Context& ctxt)
     {
         if (device.empty())
         {
-            std::cout << "You must specify a device for enrolling a template" << std::endl;
+            ctxt.cout << "You must specify a device for enrolling a template" << std::endl;
             return EXIT_FAILURE;
         }
 
@@ -71,10 +63,10 @@
 
         auto op = device->template_store().enroll(biometry::Application::system(), user);
 
-        std::cout << "Starting template enrollment for " << user << " to " << descriptor->name() << std::endl;
+        ctxt.cout << "Starting template enrollment for " << user << " to " << descriptor->name() << std::endl;
 
         op->start_with_observer(std::make_shared<TracingObserver<biometry::TemplateStore::Enrollment>>());
 
         return 0;
-    };
+    });
 }

=== modified file 'src/biometry/cmds/enroll.h'
--- src/biometry/cmds/enroll.h	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/enroll.h	2016-05-10 11:29:00 +0000
@@ -36,7 +36,7 @@
 namespace cmds
 {
 /// @brief Enroll requests enrollment of a new template to a biometric device.
-class Enroll : public util::cli::Command
+class Enroll : public util::cli::CommandWithFlagsAndAction
 {
 public:
     /// @brief Enroll creates a new instance, initializing flags to default values.

=== removed file 'src/biometry/cmds/help.cpp'
--- src/biometry/cmds/help.cpp	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/help.cpp	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- *
- */
-
-#include <biometry/cmds/help.h>
-
-namespace cli = biometry::util::cli;
-
-biometry::cmds::Help::Help(const CommandEnumerator& enumerator)
-    : Command{{Name{"help"}, Usage{"help"}, Description{"print a help message and exit"}, {}}, [this]()
-      {
-          std::cout << "Usage: biometryd [COMMAND] \n"
-              "\n"
-              "biometryd mediates access to biometric devices. \n"
-              "\n"
-              "Commands:\n";
-          Help::enumerator([](const Command::Ptr& command)
-          {
-              std::cout << "  " << command->info().name << " " << command->info().description << std::endl;
-          });
-          return EXIT_FAILURE;
-      }},
-      enumerator{enumerator}
-{
-}

=== removed file 'src/biometry/cmds/help.h'
--- src/biometry/cmds/help.h	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/help.h	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2016 Canonical, Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- * Authored by: Thomas Voß <[e-mail]>
- *
- */
-
-#ifndef BIOMETRYD_CMDS_HELP_H_
-#define BIOMETRYD_CMDS_HELP_H_
-
-#include <biometry/util/cli.h>
-
-#include <functional>
-#include <iostream>
-#include <memory>
-
-namespace biometry
-{
-namespace cmds
-{
-class Help : public util::cli::Command
-{
-public:
-    typedef std::function<void(const Command::Ptr&)> Enumerator;
-    typedef std::function<void(const Enumerator&)> CommandEnumerator;
-
-    Help(const CommandEnumerator& enumerator);
-
-private:
-    CommandEnumerator enumerator;
-};
-}
-}
-
-#endif // BIOMETRYD_CMDS_HELP_H_

=== modified file 'src/biometry/cmds/identify.cpp'
--- src/biometry/cmds/identify.cpp	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/identify.cpp	2016-05-10 11:29:00 +0000
@@ -37,15 +37,15 @@
 namespace cli = biometry::util::cli;
 
 biometry::cmds::Identify::Identify()
-    : Command{{Name{"identify"}, Usage{"identify"}, Description{"tries to identify the user holding the device"}, {}}}
+    : CommandWithFlagsAndAction{cli::Name{"identify"}, cli::Usage{"identify"}, cli::Description{"tries to identify the user holding the device"}}
 {
-    mutable_info().flags.push_back(cli::make_flag(Name{"device"}, Description{"The device to enroll to"}, device));
-    mutable_info().flags.push_back(cli::make_flag(Command::Name{"config"}, Command::Description{"The daemon configuration"}, config));
-    mutable_run() = [this]()
+    flag(cli::make_flag(cli::Name{"device"}, cli::Description{"The device to enroll to"}, device));
+    flag(cli::make_flag(cli::Name{"config"}, cli::Description{"The daemon configuration"}, config));
+    action([this](const cli::Command::Context& ctxt)
     {
         if (device.empty())
         {
-            std::cout << "You must specify a device for identification" << std::endl;
+            ctxt.cout << "You must specify a device for identification" << std::endl;
             return EXIT_FAILURE;
         }
 
@@ -62,10 +62,10 @@
 
         auto op = device->identifier().identify_user(biometry::Application::system(), biometry::Reason{"requested by cli"});
 
-        std::cout << "Starting identification using device " << descriptor->name() << std::endl;
+        ctxt.cout << "Starting identification using device " << descriptor->name() << std::endl;
 
         op->start_with_observer(std::make_shared<TracingObserver<biometry::Identification>>());
 
         return 0;
-    };
+    });
 }

=== modified file 'src/biometry/cmds/identify.h'
--- src/biometry/cmds/identify.h	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/identify.h	2016-05-10 11:29:00 +0000
@@ -36,7 +36,7 @@
 namespace cmds
 {
 /// @brief Identify requests identification of the user.
-class Identify : public util::cli::Command
+class Identify : public util::cli::CommandWithFlagsAndAction
 {
 public:
     /// @brief Enroll creates a new instance, initializing flags to default values.

=== modified file 'src/biometry/cmds/list_devices.cpp'
--- src/biometry/cmds/list_devices.cpp	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/list_devices.cpp	2016-05-10 11:29:00 +0000
@@ -25,12 +25,13 @@
 namespace cli = biometry::util::cli;
 
 biometry::cmds::ListDevices::ListDevices()
-    : Command{{Name{"list-devices"}, Usage{"list-devices"}, Description{"lists all known devices"}, {}}, []()
-      {
-          std::cout << "Known devices:" << std::endl;
-          for (const auto& pair : biometry::device_registry())
-              std::cout << " - " << pair.first << "\t" << pair.second->description() << std::endl;
-          return 0;
-      }}
+    : CommandWithFlagsAndAction{cli::Name{"list-devices"}, cli::Usage{"list-devices"}, cli::Description{"lists all known devices"}}
 {
+    action([](const cli::Command::Context& ctxt)
+    {
+        ctxt.cout << "Known devices:" << std::endl;
+        for (const auto& pair : biometry::device_registry())
+            ctxt.cout << " - " << pair.first << "\t" << pair.second->description() << std::endl;
+        return 0;
+    });
 }

=== modified file 'src/biometry/cmds/list_devices.h'
--- src/biometry/cmds/list_devices.h	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/list_devices.h	2016-05-10 11:29:00 +0000
@@ -26,7 +26,7 @@
 {
 namespace cmds
 {
-class ListDevices : public util::cli::Command
+class ListDevices : public util::cli::CommandWithFlagsAndAction
 {
 public:
     ListDevices();

=== modified file 'src/biometry/cmds/run.cpp'
--- src/biometry/cmds/run.cpp	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/run.cpp	2016-05-10 11:29:00 +0000
@@ -47,11 +47,11 @@
 
 
 biometry::cmds::Run::Run(const BusFactory& bus_factory)
-    : Command{{Name{"run"}, Usage{"run"}, Description{"run the daemon"}, {}}},
+    : CommandWithFlagsAndAction{cli::Name{"run"}, cli::Usage{"run"}, cli::Description{"run the daemon"}},
       bus_factory{bus_factory}
 {
-    mutable_info().flags.push_back(cli::make_flag(Command::Name{"config"}, Command::Description{"The daemon configuration"}, config));
-    mutable_run() = [this]()
+    flag(cli::make_flag(cli::Name{"config"}, cli::Description{"The daemon configuration"}, config));
+    action([this](const cli::Command::Context&)
     {
         auto trap = core::posix::trap_signals_for_all_subsequent_threads({core::posix::Signal::sig_term});
         trap->signal_raised().connect([trap](const core::posix::Signal&)
@@ -59,8 +59,6 @@
             trap->stop();
         });
 
-        std::cout << "here " << config.get() << std::endl;
-
         using StreamingJsonConfigurationBuilder = util::StreamingConfigurationBuilder<util::JsonConfigurationBuilder>;
         StreamingJsonConfigurationBuilder builder
         {
@@ -92,5 +90,5 @@
         runtime->stop();
 
         return EXIT_SUCCESS;
-    };
+    });
 }

=== modified file 'src/biometry/cmds/run.h'
--- src/biometry/cmds/run.h	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/run.h	2016-05-10 11:29:00 +0000
@@ -36,7 +36,7 @@
 {
 namespace cmds
 {
-class Run : public util::cli::Command
+class Run : public util::cli::CommandWithFlagsAndAction
 {
 public:
     /// @brief BusFactory models creation of bus instances.

=== modified file 'src/biometry/cmds/version.cpp'
--- src/biometry/cmds/version.cpp	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/version.cpp	2016-05-10 11:29:00 +0000
@@ -23,12 +23,13 @@
 namespace cli = biometry::util::cli;
 
 biometry::cmds::Version::Version()
-    : Command{{Name{"version"}, Usage{"version"}, Description{"print the version of the daemon"}, {}}, []()
-      {
-          std::uint32_t major, minor, patch;
-          biometry::version(major, minor, patch);
-          std::cout << "biometryd " << major << "." << minor << "." << patch << std::endl;
-          return 0;
-      }}
+    : CommandWithFlagsAndAction{cli::Name{"version"}, cli::Usage{"version"}, cli::Description{"print the version of the daemon"}}
 {
+    action([](const cli::Command::Context& ctxt)
+    {
+        std::uint32_t major, minor, patch;
+        biometry::version(major, minor, patch);
+        ctxt.cout << "biometryd " << major << "." << minor << "." << patch << std::endl;
+        return 0;
+    });
 }

=== modified file 'src/biometry/cmds/version.h'
--- src/biometry/cmds/version.h	2016-05-09 14:37:52 +0000
+++ src/biometry/cmds/version.h	2016-05-10 11:29:00 +0000
@@ -30,7 +30,7 @@
 {
 namespace cmds
 {
-class Version : public util::cli::Command
+class Version : public util::cli::CommandWithFlagsAndAction
 {
 public:
     Version();

=== modified file 'src/biometry/daemon.cpp'
--- src/biometry/daemon.cpp	2016-05-09 14:37:52 +0000
+++ src/biometry/daemon.cpp	2016-05-10 11:29:00 +0000
@@ -22,7 +22,6 @@
 #include <biometry/devices/plugin/enumerator.h>
 
 #include <biometry/cmds/enroll.h>
-#include <biometry/cmds/help.h>
 #include <biometry/cmds/identify.h>
 #include <biometry/cmds/list_devices.h>
 #include <biometry/cmds/run.h>
@@ -37,106 +36,18 @@
 namespace cli = biometry::util::cli;
 namespace po = boost::program_options;
 
-namespace
-{
-std::multimap<cli::Command::Name, std::function<void(const std::string&)>>& notifiers()
-{
-    static std::multimap<cli::Command::Name, std::function<void(const std::string&)>> instance;
-    return instance;
-}
-}
-
-cli::Command::Flag::Flag(const Name& name, const Description& description)
-    : name_{name},
-      description_{description}
-{
-}
-
-const cli::Command::Name& cli::Command::Flag::name() const
-{
-    return name_;
-}
-
-const cli::Command::Description& cli::Command::Flag::description() const
-{
-    return description_;
-}
-
-biometry::Daemon::Daemon() : device_registrar{biometry::devices::plugin::DirectoryEnumerator{Configuration::default_plugin_directory()}}
-{
-    install_command(std::make_shared<cmds::Enroll>());
-    install_command(std::make_shared<cmds::Identify>());
-    install_command(std::make_shared<cmds::ListDevices>());
-    install_command(std::make_shared<cmds::Run>());
-    install_command(std::make_shared<cmds::Version>());
-
-    help = std::make_shared<cmds::Help>([this](const cmds::Help::Enumerator& enumerator)
-    {
-        for (const auto& pair : cmds)
-            enumerator(pair.second);
-    });
+biometry::Daemon::Daemon()
+    : device_registrar{biometry::devices::plugin::DirectoryEnumerator{Configuration::default_plugin_directory()}},
+      cmd{cli::Name{"biometryd"}, cli::Usage{"biometryd"}, cli::Description{"biometryd"}}
+{
+    cmd.command(std::make_shared<cmds::Enroll>())
+       .command(std::make_shared<cmds::Identify>())
+       .command(std::make_shared<cmds::ListDevices>())
+       .command(std::make_shared<cmds::Run>())
+       .command(std::make_shared<cmds::Version>());
 }
 
 int biometry::Daemon::run(const std::vector<std::string>& args)
 {
-    po::positional_options_description pdesc;
-    pdesc.add("command", 1);
-
-    po::options_description desc("Options");
-    desc.add_options()
-            ("command", po::value<std::string>()->default_value(help->info().name), "the command to be executed");
-
-    for (const auto& pair : cmds)
-    {
-        po::options_description cd(pair.first);
-        for (auto flag : pair.second->info().flags)
-        {
-            // Depending on the name of the flag, we only ever install it once
-            // to the options_description to avoid triggering an issue caused
-            // by ambigious options. Instead, we relay the notify method to inform multiple
-            // flags of the same name that a new value is available.
-            if (notifiers().count(flag->name()) == 0)
-            {
-                auto v = po::value<std::string>()->notifier([flag](const std::string& s)
-                {
-                    // Iterate over all known identifiers.
-                    auto range = notifiers().equal_range(flag->name());
-                    while (range.first != range.second)
-                    {
-                        (range.first->second)(s);
-                        ++range.first;
-                    }
-                });
-
-                cd.add_options()(flag->name().as_string().c_str(), v, flag->description().as_string().c_str());
-            }
-
-            notifiers().insert(std::make_pair(flag->name(), [flag](const std::string& s) { flag->notify(s); }));
-        }
-        desc.add(cd);
-    }
-
-    try
-    {
-        po::variables_map vm;
-        po::store(po::command_line_parser(args).options(desc).positional(pdesc).run(), vm);
-        po::notify(vm);
-
-        auto command = vm["command"].as<std::string>();
-
-        if (command == "help")
-            return help->run();
-
-        return cmds[command]->run();
-    }
-    catch (const std::exception& e)
-    {
-        std::cout << e.what() << std::endl;
-        return help->run();
-    }
-}
-
-void biometry::Daemon::install_command(const cli::Command::Ptr& command)
-{
-    cmds[command->info().name] = command;
+    return cmd.run({std::cin, std::cout, args});
 }

=== modified file 'src/biometry/daemon.h'
--- src/biometry/daemon.h	2016-05-09 14:37:52 +0000
+++ src/biometry/daemon.h	2016-05-10 11:29:00 +0000
@@ -54,11 +54,8 @@
     int run(const std::vector<std::string>& args);
 
 private:
-    void install_command(const util::cli::Command::Ptr& command);
-
     DeviceRegistrar device_registrar;
-    std::unordered_map<std::string, util::cli::Command::Ptr> cmds;
-    util::cli::Command::Ptr help;
+    util::cli::CommandWithSubcommands cmd;
 };
 
 

=== modified file 'src/biometry/daemon_main.cpp'
--- src/biometry/daemon_main.cpp	2016-05-04 12:17:44 +0000
+++ src/biometry/daemon_main.cpp	2016-05-10 11:29:00 +0000
@@ -19,11 +19,12 @@
 
 #include <biometry/daemon.h>
 
+#include <biometry/util/cli.h>
+
+namespace cli = biometry::util::cli;
+
 int main(int argc, char** argv)
 {
-    std::vector<std::string> args;
-    for (int i = 1; i < argc; i++) args.emplace_back(argv[i]);
-
     biometry::Daemon biometryd;
-    return biometryd.run(args);
+    return biometryd.run(cli::args(argc, argv));
 }

=== modified file 'src/biometry/util/cli.cpp'
--- src/biometry/util/cli.cpp	2016-05-09 14:37:52 +0000
+++ src/biometry/util/cli.cpp	2016-05-10 11:29:00 +0000
@@ -19,30 +19,245 @@
 
 #include <biometry/util/cli.h>
 
+#include <boost/format.hpp>
+#include <boost/program_options.hpp>
+
 namespace cli = biometry::util::cli;
-
-cli::Command::Info cli::Command::info() const
-{
-    return info_;
-}
-
-int cli::Command::run()
-{
-    return run_();
-}
-
-cli::Command::Command(const cli::Command::Info& info, const std::function<int()>& run)
-    : info_(info),
-      run_{run}
-{
-}
-
-cli::Command::Info& cli::Command::mutable_info()
-{
-    return info_;
-}
-
-std::function<int()>& cli::Command::mutable_run()
-{
-    return run_;
+namespace po = boost::program_options;
+
+namespace
+{
+namespace pattern
+{
+static constexpr const char* help_for_command_with_subcommands =
+"NAME:\n"
+"    %1% - %2%\n"
+"\n"
+"USAGE:\n"
+"    %3% [command options] [arguments...]";
+
+static constexpr const char* commands   = "COMMANDS:";
+static constexpr const char* command    = "    %1% %2%";
+
+static constexpr const char* options    = "OPTIONS:";
+static constexpr const char* option     = "    --%1% %2%";
+}
+
+void add_to_desc_for_flags(po::options_description& desc, const std::set<cli::Flag::Ptr>& flags)
+{
+    for (auto flag : flags)
+    {
+        auto v = po::value<std::string>()->notifier([flag](const std::string& s)
+        {
+            flag->notify(s);
+        });
+        desc.add_options()(flag->name().as_string().c_str(), v, flag->description().as_string().c_str());
+    }
+}
+}
+
+std::vector<std::string> cli::args(int argc, char **argv)
+{
+    std::vector<std::string> result;
+    for (int i = 1; i < argc; i++) result.push_back(argv[i]);
+    return result;
+}
+
+const cli::Name& cli::Flag::name() const
+{
+    return name_;
+}
+
+const cli::Description& cli::Flag::description() const
+{
+    return description_;
+}
+
+cli::Flag::Flag(const Name& name, const Description& description)
+    : name_{name},
+      description_{description}
+{
+}
+
+cli::Name cli::Command::name() const
+{
+    return name_;
+}
+
+cli::Usage cli::Command::usage() const
+{
+    return usage_;
+}
+
+cli::Description cli::Command::description() const
+{
+    return description_;
+}
+
+cli::Command::Command(const cli::Name& name, const cli::Usage& usage, const cli::Description& description)
+    : name_(name),
+      usage_(usage),
+      description_(description)
+{
+}
+
+cli::CommandWithSubcommands::CommandWithSubcommands(const Name& name, const Usage& usage, const Description& description)
+    : Command{name, usage, description}
+{
+    command(std::make_shared<cmd::Help>(*this));
+}
+
+cli::CommandWithSubcommands& cli::CommandWithSubcommands::command(const Command::Ptr& command)
+{
+    commands_[command->name().as_string()] = command;
+    return *this;
+}
+
+cli::CommandWithSubcommands& cli::CommandWithSubcommands::flag(const Flag::Ptr& flag)
+{
+    flags_.insert(flag);
+    return *this;
+}
+
+void cli::CommandWithSubcommands::help(std::ostream& out)
+{
+    out << boost::format(pattern::help_for_command_with_subcommands)
+           % name().as_string() % usage().as_string()
+           % name().as_string() << std::endl;
+
+    if (flags_.size() > 0)
+    {
+        out << std::endl << pattern::options << std::endl;
+        for (const auto& flag : flags_)
+            out << boost::format(pattern::option) % flag->name() % flag->description() << std::endl;
+    }
+
+    if (commands_.size() > 0)
+    {
+        out << std::endl << pattern::commands << std::endl;
+        for (const auto& cmd : commands_)
+            out << boost::format(pattern::command) % cmd.second->name() % cmd.second->description() << std::endl;
+    }
+}
+
+int cli::CommandWithSubcommands::run(const cli::Command::Context& ctxt)
+{
+    po::positional_options_description pdesc;
+    pdesc.add("command", 1);
+
+    po::options_description desc("Options");
+    desc.add_options()("command", po::value<std::string>()->required(), "the command to be executed");
+
+    add_to_desc_for_flags(desc, flags_);
+
+    try
+    {
+        po::variables_map vm;
+        auto parsed = po::command_line_parser(ctxt.args).options(desc).positional(pdesc).allow_unregistered().run();
+        po::store(parsed, vm);
+        po::notify(vm);
+
+        return commands_[vm["command"].as<std::string>()]->run(cli::Command::Context
+        {
+            ctxt.cin,
+            ctxt.cout,
+            po::collect_unrecognized(parsed.options, po::include_positional)
+        });
+    }
+    catch (const po::error& e)
+    {
+        ctxt.cout << e.what() << std::endl;
+        help(ctxt.cout);
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_FAILURE;
+}
+
+cli::CommandWithFlagsAndAction::CommandWithFlagsAndAction(const Name& name, const Usage& usage, const Description& description)
+    : Command{name, usage, description}
+{
+}
+
+cli::CommandWithFlagsAndAction& cli::CommandWithFlagsAndAction::flag(const Flag::Ptr& flag)
+{
+    flags_.insert(flag);
+    return *this;
+}
+
+cli::CommandWithFlagsAndAction& cli::CommandWithFlagsAndAction::action(const Action& action)
+{
+    action_ = action;
+    return *this;
+}
+
+int cli::CommandWithFlagsAndAction::run(const Context& ctxt)
+{
+    po::options_description cd(name().as_string());
+
+    bool help_requested{false};
+    cd.add_options()("help", po::bool_switch(&help_requested), "produces a help message");
+
+    add_to_desc_for_flags(cd, flags_);
+
+    try
+    {
+        po::variables_map vm;
+        auto parsed = po::command_line_parser(ctxt.args).options(cd).allow_unregistered().run();
+        po::store(parsed, vm);
+        po::notify(vm);
+
+        if (help_requested)
+        {
+            help(ctxt.cout);
+            return EXIT_SUCCESS;
+        }
+
+        return action_(cli::Command::Context
+        {
+            ctxt.cin,
+            ctxt.cout,
+            po::collect_unrecognized(parsed.options, po::include_positional)
+        });
+    }
+    catch (const po::error& e)
+    {
+        ctxt.cout << e.what() << std::endl;
+        help(ctxt.cout);
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_FAILURE;
+}
+
+void cli::CommandWithFlagsAndAction::help(std::ostream& out)
+{
+    out << boost::format(pattern::help_for_command_with_subcommands)
+           % name().as_string() % description().as_string()
+           % name().as_string() << std::endl;
+
+    if (flags_.size() > 0)
+    {
+        out << std::endl << boost::format(pattern::options) << std::endl;
+        for (const auto& flag : flags_)
+            out << boost::format(pattern::option) % flag->name() % flag->description() << std::endl;
+    }
+}
+
+cli::cmd::Help::Help(Command& cmd)
+    : Command{cli::Name{"help"}, cli::Usage{"prints a short help message"}, cli::Description{"prints a short help message"}},
+      command{cmd}
+{
+}
+
+// From Command
+int cli::cmd::Help::run(const Context &context)
+{
+    command.help(context.cout);
+    return EXIT_FAILURE;
+}
+
+void cli::cmd::Help::help(std::ostream &out)
+{
+    command.help(out);
 }

=== modified file 'src/biometry/util/cli.h'
--- src/biometry/util/cli.h	2016-05-09 14:37:52 +0000
+++ src/biometry/util/cli.h	2016-05-10 11:29:00 +0000
@@ -26,9 +26,11 @@
 #include <iomanip>
 #include <iostream>
 #include <memory>
+#include <set>
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <unordered_map>
 
 namespace biometry
 {
@@ -78,170 +80,263 @@
     return out << std::setw(max) << std::left << scs.as_string();
 }
 
+// We are imposing size constraints to ensure a consistent CLI layout.
+typedef SizeConstrainedString<15> Name;
+typedef SizeConstrainedString<60> Usage;
+typedef SizeConstrainedString<60> Description;
+
+/// @brief Flag models an input parameter to a command.
+class BIOMETRY_DLL_PUBLIC Flag : public DoNotCopyOrMove
+{
+public:
+    // Safe us some typing.
+    typedef std::shared_ptr<Flag> Ptr;
+
+    /// @brief notify announces a new value to the flag.
+    virtual void notify(const std::string& value) = 0;
+    /// @brief name returns the name of the Flag.
+    const Name& name() const;
+    /// @brief description returns a human-readable description of the flag.
+    const Description& description() const;
+
+protected:
+    /// @brief Flag creates a new instance, initializing name and description
+    /// from the given values.
+    Flag(const Name& name, const Description& description);
+
+private:
+    Name name_;
+    Description description_;
+};
+
+/// @brief TypedFlag implements Flag relying on operator<< and operator>> to read/write values to/from strings.
+template<typename T>
+class BIOMETRY_DLL_PUBLIC TypedFlag : public Flag
+{
+public:
+    typedef std::shared_ptr<TypedFlag<T>> Ptr;
+
+    TypedFlag(const Name& name, const Description& description) : Flag{name, description}
+    {
+    }
+
+    /// @brief value installs the given value in the flag.
+    TypedFlag& value(const T& value)
+    {
+        value_ = value;
+        return *this;
+    }
+
+    /// @brief value returns the optional value associated with the flag.
+    const Optional<T>& value() const
+    {
+        return value_;
+    }
+
+    /// @brief notify tries to unwrap a value of type T from value.
+    void notify(const std::string& s) override
+    {
+        std::stringstream ss{s};
+        T value; ss >> value;
+        value_ = value;
+    }
+
+private:
+    Optional<T> value_;
+};
+
+/// @brief TypedReferenceFlag implements Flag, relying on operator<</>> to convert to/from string representations,
+/// updating the given mutable reference to a value of type T.
+template<typename T>
+class BIOMETRY_DLL_PUBLIC TypedReferenceFlag : public Flag
+{
+public:
+    // Safe us some typing.
+    typedef std::shared_ptr<TypedReferenceFlag<T>> Ptr;
+
+    /// @brief TypedReferenceFlag initializes a new instance with name, description and value.
+    TypedReferenceFlag(const Name& name, const Description& description, T& value)
+        : Flag{name, description},
+          value_{value}
+    {
+    }
+
+    /// @brief notify tries to unwrap a value of type T from value,
+    /// relying on operator>> to read from given string s.
+    void notify(const std::string& s) override
+    {
+        std::stringstream ss{s};
+        ss >> value_.get();
+    }
+
+private:
+    std::reference_wrapper<T> value_;
+};
+
+/// @brief OptionalTypedReferenceFlag handles Optional<T> references, making sure that
+/// a value is always read on notify, even if the Optional<T> wasn't initialized previously.
+template<typename T>
+class BIOMETRY_DLL_PUBLIC OptionalTypedReferenceFlag : public Flag
+{
+public:
+    typedef std::shared_ptr<OptionalTypedReferenceFlag<T>> Ptr;
+
+    OptionalTypedReferenceFlag(const Name& name, const Description& description, Optional<T>& value)
+        : Flag{name, description},
+          value_{value}
+    {
+    }
+
+    /// @brief notify tries to unwrap a value of type T from value.
+    void notify(const std::string& s) override
+    {
+        std::stringstream ss{s}; T value; ss >> value;
+        value_.get() = value;
+    }
+
+private:
+    std::reference_wrapper<Optional<T>> value_;
+};
+
 /// @brief Command abstracts an individual command available from the daemon.
 class BIOMETRY_DLL_PUBLIC Command : public DoNotCopyOrMove
 {
 public:
     // Safe us some typing
-    typedef std::shared_ptr<Command> Ptr;
-
-    // We are imposing size constraints to ensure a consistent CLI layout.
-    typedef SizeConstrainedString<15> Name;
-    typedef SizeConstrainedString<60> Usage;
-    typedef SizeConstrainedString<60> Description;
-
-    /// @brief Flag models an input parameter to a command.
-    class Flag : public DoNotCopyOrMove
-    {
-    public:
-        // Safe us some typing.
-        typedef std::shared_ptr<Flag> Ptr;
-
-        /// @brief notify announces a new value to the flag.
-        virtual void notify(const std::string& value) = 0;
-        /// @brief name returns the name of the Flag.
-        const Name& name() const;
-        /// @brief description returns a human-readable description of the flag.
-        const Description& description() const;
-
-    protected:
-        /// @brief Flag creates a new instance, initializing name and description
-        /// from the given values.
-        Flag(const Name& name, const Description& description);
-
-    private:
-        Name name_;
-        Description description_;
-    };
-
-    /// @brief Info bundles details about a command.
-    struct Info
-    {
-        Name name;  ///< The name of the command.
-        Usage usage; ///< Short usage description of the command.
-        Description description; /// More detailed description of the command.
-        std::vector<Flag::Ptr> flags; /// Flags known to the command.
-    };
-
-    template<typename T>
-    class TypedFlag : public Flag
-    {
-    public:
-        typedef std::shared_ptr<TypedFlag<T>> Ptr;
-
-        TypedFlag(const Name& name, const Description& description) : Flag{name, description}
-        {
-        }
-
-        /// @brief value installs the given value in the flag.
-        TypedFlag& value(const T& value)
-        {
-            value_ = value;
-            return *this;
-        }
-
-        /// @brief value returns the optional value associated with the flag.
-        const Optional<T>& value() const
-        {
-            return value_;
-        }
-
-        /// @brief notify tries to unwrap a value of type T from value.
-        void notify(const std::string& s) override
-        {
-            std::stringstream ss{s};
-            T value; ss >> value;
-            value_ = value;
-        }
-
-    private:
-        Optional<T> value_;
-    };
-
-    template<typename T>
-    class TypedReferenceFlag : public Flag
-    {
-    public:
-        typedef std::shared_ptr<TypedReferenceFlag<T>> Ptr;
-
-        TypedReferenceFlag(const Name& name, const Description& description, T& value)
-            : Flag{name, description},
-              value_{value}
-        {
-        }
-
-        /// @brief notify tries to unwrap a value of type T from value.
-        void notify(const std::string& s) override
-        {
-            std::stringstream ss{s};
-            ss >> value_.get();
-        }
-
-    private:
-        std::reference_wrapper<T> value_;
-    };
-
-    /// @brief OptionalTypedReferenceFlag handles Optional<T> references, making sure that
-    /// a value is always read on notify, even if the Optional<T> wasn't initialized previously.
-    template<typename T>
-    class OptionalTypedReferenceFlag : public Flag
-    {
-    public:
-        typedef std::shared_ptr<OptionalTypedReferenceFlag<T>> Ptr;
-
-        OptionalTypedReferenceFlag(const Name& name, const Description& description, Optional<T>& value)
-            : Flag{name, description},
-              value_{value}
-        {
-        }
-
-        /// @brief notify tries to unwrap a value of type T from value.
-        void notify(const std::string& s) override
-        {
-            std::stringstream ss{s}; T value; ss >> value;
-            value_.get() = value;
-        }
-
-    private:
-        std::reference_wrapper<Optional<T>> value_;
-    };
-
-    /// @brief info returns Info about a command.
-    virtual Info info() const;
+    typedef std::shared_ptr<Command> Ptr;    
+
+    /// @brief Context bundles information passed to Command::run invocations.
+    struct Context
+    {
+        std::istream& cin;              ///< The std::istream that should be used for reading.
+        std::ostream& cout;             ///< The std::ostream that should be used for writing.
+        std::vector<std::string> args;  ///< The command line args.
+    };
+
+    /// @brief name returns the Name of the command.
+    virtual Name name() const;
+
+    /// @brief usage returns a short usage string for the command.
+    virtual Usage usage() const;
+
+    /// @brief description returns a longer string explaining the command.
+    virtual Description description() const;
+
     /// @brief run puts the command to execution.
-    virtual int run();
+    virtual int run(const Context& context) = 0;
+
+    /// @brief help prints information about a command to out.
+    virtual void help(std::ostream& out) = 0;
 
 protected:
-    /// @brief Command initializes a new instance with the given info and functor.
-    Command(const Info& info, const std::function<int()>& run = std::function<int()>());
-
-    /// @brief info returns a mutable reference to info_.
-    Info& mutable_info();
-
-    /// @brief run returns a mutable reference to run_.
-    std::function<int()>& mutable_run();
-
-private:
-    Info info_;
-    std::function<int()> run_;
-};
-
-template<typename T>
-BIOMETRY_DLL_PUBLIC typename Command::TypedFlag<T>::Ptr make_flag(const Command::Name& name, const Command::Description& desc)
-{
-    return std::make_shared<Command::TypedFlag<T>>(name, desc);
-}
-
-template<typename T>
-BIOMETRY_DLL_PUBLIC typename Command::TypedReferenceFlag<T>::Ptr make_flag(const Command::Name& name, const Command::Description& desc, T& value)
-{
-    return std::make_shared<Command::TypedReferenceFlag<T>>(name, desc, value);
-}
-
-template<typename T>
-BIOMETRY_DLL_PUBLIC typename Command::OptionalTypedReferenceFlag<T>::Ptr make_flag(const Command::Name& name, const Command::Description& desc, Optional<T>& value)
-{
-    return std::make_shared<Command::OptionalTypedReferenceFlag<T>>(name, desc, value);
+    /// @brief Command initializes a new instance with the given name, usage and description.
+    Command(const Name& name, const Usage& usage, const Description& description);
+
+    /// @brief name adjusts the name of the command to n.
+    // virtual void name(const Name& n);
+    /// @brief usage adjusts the usage string of the comand to u.
+    // virtual void usage(const Usage& u);
+    /// @brief description adjusts the description string of the command to d.
+    // virtual void description(const Description& d);
+
+private:
+    Name name_;
+    Usage usage_;
+    Description description_;
+};
+
+/// @brief CommandWithSubcommands implements Command, selecting one of a set of actions.
+class BIOMETRY_DLL_PUBLIC CommandWithSubcommands : public Command
+{
+public:
+    typedef std::shared_ptr<CommandWithSubcommands> Ptr;
+    typedef std::function<int(const Context&)> Action;
+
+    /// @brief CommandWithSubcommands initializes a new instance with the given name, usage and description
+    CommandWithSubcommands(const Name& name, const Usage& usage, const Description& description);
+
+    /// @brief command adds the given command to the set of known commands.
+    CommandWithSubcommands& command(const Command::Ptr& command);
+
+    /// @brief flag adds the given flag to the set of known flags.
+    CommandWithSubcommands& flag(const Flag::Ptr& flag);
+
+    // From Command
+    int run(const Context& context) override;
+    void help(std::ostream &out) override;
+
+private:
+    std::unordered_map<std::string, Command::Ptr> commands_;
+    std::set<Flag::Ptr> flags_;
+};
+
+/// @brief CommandWithFlagsAction implements Command, executing an Action after handling
+class BIOMETRY_DLL_PUBLIC CommandWithFlagsAndAction : public Command
+{
+public:
+    typedef std::shared_ptr<CommandWithFlagsAndAction> Ptr;
+    typedef std::function<int(const Context&)> Action;
+
+    /// @brief CommandWithFlagsAndAction initializes a new instance with the given name, usage and description
+    CommandWithFlagsAndAction(const Name& name, const Usage& usage, const Description& description);
+
+    /// @brief flag adds the given flag to the set of known flags.
+    CommandWithFlagsAndAction& flag(const Flag::Ptr& flag);
+
+    /// @brief action installs the given action.
+    CommandWithFlagsAndAction& action(const Action& action);
+
+    // From Command
+    int run(const Context& context) override;
+    void help(std::ostream &out) override;
+
+private:
+    std::set<Flag::Ptr> flags_;
+    Action action_;
+};
+
+namespace cmd
+{
+/// @brief HelpFor prints a help message for the given command on execution.
+class Help : public Command
+{
+public:
+    /// @brief HelpFor initializes a new instance with the given reference to a cmd.
+    explicit Help(Command& cmd);
+
+    // From Command
+    int run(const Context &context) override;
+    void help(std::ostream &out) override;
+
+private:
+    /// @cond
+    Command& command;
+    /// @endcond
+};
+}
+
+/// @brief args returns a vector of strings assembled from argc and argv.
+BIOMETRY_DLL_PUBLIC std::vector<std::string> args(int argc, char** argv);
+
+/// @brief make_flag returns a flag with the given name and description.
+template<typename T>
+BIOMETRY_DLL_PUBLIC typename TypedFlag<T>::Ptr make_flag(const Name& name, const Description& description)
+{
+    return std::make_shared<TypedFlag<T>>(name, description);
+}
+
+/// @brief make_flag returns a flag with the given name and description, notifying updates to value.
+template<typename T>
+BIOMETRY_DLL_PUBLIC typename TypedReferenceFlag<T>::Ptr make_flag(const Name& name, const Description& desc, T& value)
+{
+    return std::make_shared<TypedReferenceFlag<T>>(name, desc, value);
+}
+
+/// @brief make_flag returns a flag with the given name and description, updating the given optional value.
+template<typename T>
+BIOMETRY_DLL_PUBLIC typename OptionalTypedReferenceFlag<T>::Ptr make_flag(const Name& name, const Description& desc, Optional<T>& value)
+{
+    return std::make_shared<OptionalTypedReferenceFlag<T>>(name, desc, value);
 }
 }
 }

=== modified file 'tests/test_daemon.cpp'
--- tests/test_daemon.cpp	2016-05-09 14:37:52 +0000
+++ tests/test_daemon.cpp	2016-05-10 11:29:00 +0000
@@ -65,18 +65,18 @@
 
 TEST(TypedFlag, stores_name_and_desc_passed_on_construction)
 {
-    cli::Command::Name name{"42"};
-    cli::Command::Description desc{"43"};
-    cli::Command::TypedFlag<int> flag{name, desc};
+    cli::Name name{"42"};
+    cli::Description desc{"43"};
+    cli::TypedFlag<int> flag{name, desc};
     EXPECT_EQ(name, flag.name());
     EXPECT_EQ(desc, flag.description());
 }
 
 TEST(TypedFlag, parses_string_on_notify_and_sets_value)
 {
-    cli::Command::Name name{"42"};
-    cli::Command::Description desc{"43"};
-    cli::Command::TypedFlag<int> flag{name, desc};
+    cli::Name name{"42"};
+    cli::Description desc{"43"};
+    cli::TypedFlag<int> flag{name, desc};
     EXPECT_FALSE(flag.value().is_initialized());
     flag.notify("42");
     EXPECT_TRUE(flag.value().is_initialized());
@@ -153,7 +153,7 @@
         biometry::Daemon daemon;
         auto rc = daemon.run(
         {
-            "run", "--config", "test.json"
+            "run", "--config=test.json"
         });
 
         return rc == EXIT_SUCCESS ? core::posix::exit::Status::success : core::posix::exit::Status::failure;