add a 'task sync' command using a copy of the test server

cli/src/cmd/mod.rs

@@ -1,7 +1,5 @@
 use clap::{App, ArgMatches};
 use failure::{Error, Fallible};
-use std::path::Path;
-use taskchampion::{taskstorage, Replica};
 
 #[macro_use]
 mod macros;
@@ -12,6 +10,7 @@ mod gc;
 mod info;
 mod list;
 mod pending;
+mod sync;
 
 /// Get a list of all subcommands in this crate
 pub(crate) fn subcommands() -> Vec<Box<dyn SubCommand>> {
@@ -21,6 +20,7 @@ pub(crate) fn subcommands() -> Vec<Box<dyn SubCommand>> {
         list::cmd(),
         pending::cmd(),
         info::cmd(),
+        sync::cmd(),
     ]
 }
 
@@ -54,24 +54,4 @@ pub(crate) trait SubCommandInvocation: std::fmt::Debug {
     fn as_any(&self) -> &dyn std::any::Any;
 }
 
-/// A command invocation contains all of the necessary regarding a single invocation of the CLI.
-#[derive(Debug)]
-pub struct CommandInvocation {
-    pub(crate) subcommand: Box<dyn SubCommandInvocation>,
-}
-
-impl CommandInvocation {
-    pub(crate) fn new(subcommand: Box<dyn SubCommandInvocation>) -> Self {
-        Self { subcommand }
-    }
-
-    pub fn run(self) -> Fallible<()> {
-        self.subcommand.run(&self)
-    }
-
-    fn get_replica(&self) -> Replica {
-        Replica::new(Box::new(
-            taskstorage::KVStorage::new(Path::new("/tmp/tasks")).unwrap(),
-        ))
-    }
-}
+pub use shared::CommandInvocation;

cli/src/cmd/shared.rs

@@ -1,6 +1,7 @@
 use clap::Arg;
 use failure::{format_err, Fallible};
-use taskchampion::{Replica, Task, Uuid};
+use std::path::Path;
+use taskchampion::{server, taskstorage, Replica, Task, Uuid};
 
 pub(super) fn task_arg<'a>() -> Arg<'a, 'a> {
     Arg::with_name("task")
@@ -26,3 +27,31 @@ pub(super) fn get_task<S: AsRef<str>>(replica: &mut Replica, task_arg: S) -> Fal
 
     Err(format_err!("Cannot interpret {:?} as a task", task_arg))
 }
+
+/// A command invocation contains all of the necessary regarding a single invocation of the CLI.
+#[derive(Debug)]
+pub struct CommandInvocation {
+    pub(crate) subcommand: Box<dyn super::SubCommandInvocation>,
+}
+
+impl CommandInvocation {
+    pub(crate) fn new(subcommand: Box<dyn super::SubCommandInvocation>) -> Self {
+        Self { subcommand }
+    }
+
+    pub fn run(self) -> Fallible<()> {
+        self.subcommand.run(&self)
+    }
+
+    // -- utilities for command invocations
+
+    pub(super) fn get_replica(&self) -> Replica {
+        Replica::new(Box::new(
+            taskstorage::KVStorage::new(Path::new("/tmp/tasks")).unwrap(),
+        ))
+    }
+
+    pub(super) fn get_server(&self) -> impl server::Server {
+        server::LocalServer::new()
+    }
+}

cli/src/cmd/sync.rs

@@ -0,0 +1,39 @@
+use clap::{App, ArgMatches, SubCommand as ClapSubCommand};
+use failure::Fallible;
+
+use crate::cmd::{ArgMatchResult, CommandInvocation};
+
+#[derive(Debug)]
+struct Invocation {}
+
+define_subcommand! {
+    fn decorate_app<'a>(&self, app: App<'a, 'a>) -> App<'a, 'a> {
+        app.subcommand(ClapSubCommand::with_name("sync").about("sync with the server"))
+    }
+
+    fn arg_match<'a>(&self, matches: &ArgMatches<'a>) -> ArgMatchResult {
+        match matches.subcommand() {
+            ("sync", _) => ArgMatchResult::Ok(Box::new(Invocation {})),
+            _ => ArgMatchResult::None,
+        }
+    }
+}
+
+subcommand_invocation! {
+    fn run(&self, command: &CommandInvocation) -> Fallible<()> {
+        let mut replica = command.get_replica();
+        let mut server = command.get_server();
+        replica.sync(&mut server)?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn parse_command() {
+        with_subcommand_invocation!(vec!["task", "sync"], |_inv| {});
+    }
+}