use ServerConfig::into_server instead of server::from_config

taskchampion/src/config.rs

@@ -1,30 +1,7 @@
 use std::path::PathBuf;
-use uuid::Uuid;
 
 /// The configuration required for a replica.  Use with [`crate::Replica::from_config`].
 pub struct ReplicaConfig {
     /// Path containing the task DB.
     pub taskdb_dir: PathBuf,
 }
-
-/// The configuration for a replica's access to a sync server.  Use with
-/// [`crate::server::from_config`].
-pub enum ServerConfig {
-    /// A local task database, for situations with a single replica.
-    Local {
-        /// Path containing the server's DB
-        server_dir: PathBuf,
-    },
-    /// A remote taskchampion-sync-server instance
-    Remote {
-        /// Sync server "origin"; a URL with schema and hostname but no path or trailing `/`
-        origin: String,
-
-        /// Client Key to identify and authenticate this replica to the server
-        client_key: Uuid,
-
-        /// Private encryption secret used to encrypt all data sent to the server.  This can
-        /// be any suitably un-guessable string of bytes.
-        encryption_secret: Vec<u8>,
-    },
-}

taskchampion/src/lib.rs

@@ -3,10 +3,14 @@
 
 This crate implements the core of TaskChampion, the [replica](crate::Replica).
 
+# Replica
+
 A TaskChampion replica is a local copy of a user's task data.  As the name suggests, several
 replicas of the same data can exist (such as on a user's laptop and on their phone) and can
 synchronize with one another.
 
+Replicas are accessed using the [`Replica`](crate::replica) type.
+
 # Task Storage
 
 The [`storage`](crate::storage) module supports pluggable storage for a replica's data.
@@ -15,7 +19,10 @@ An implementation is provided, but users of this crate can provide their own imp
 # Server
 
 Replica synchronization takes place against a server.
+Create a server with [`ServerConfig`](crate::ServerConfig).
+
 The [`server`](crate::server) module defines the interface a server must meet.
+Users can define their own server impelementations.
 
 # See Also
 
@@ -28,14 +35,15 @@ mod config;
 mod errors;
 mod replica;
 pub mod server;
+pub mod storage;
 mod task;
 mod taskdb;
-pub mod storage;
 mod utils;
 mod workingset;
 
-pub use config::{ReplicaConfig, ServerConfig};
+pub use config::ReplicaConfig;
 pub use replica::Replica;
+pub use server::{Server, ServerConfig};
 pub use task::{Priority, Status, Tag, Task, TaskMut};
 pub use workingset::WorkingSet;
 

taskchampion/src/server/config.rs

@@ -0,0 +1,40 @@
+use super::types::Server;
+use super::{LocalServer, RemoteServer};
+use failure::Fallible;
+use std::path::PathBuf;
+use uuid::Uuid;
+
+/// The configuration for a replica's access to a sync server.
+pub enum ServerConfig {
+    /// A local task database, for situations with a single replica.
+    Local {
+        /// Path containing the server's DB
+        server_dir: PathBuf,
+    },
+    /// A remote taskchampion-sync-server instance
+    Remote {
+        /// Sync server "origin"; a URL with schema and hostname but no path or trailing `/`
+        origin: String,
+
+        /// Client Key to identify and authenticate this replica to the server
+        client_key: Uuid,
+
+        /// Private encryption secret used to encrypt all data sent to the server.  This can
+        /// be any suitably un-guessable string of bytes.
+        encryption_secret: Vec<u8>,
+    },
+}
+
+impl ServerConfig {
+    /// Get a server based on this configuration
+    pub fn into_server(self) -> Fallible<Box<dyn Server>> {
+        Ok(match self {
+            ServerConfig::Local { server_dir } => Box::new(LocalServer::new(server_dir)?),
+            ServerConfig::Remote {
+                origin,
+                client_key,
+                encryption_secret,
+            } => Box::new(RemoteServer::new(origin, client_key, encryption_secret)),
+        })
+    }
+}

taskchampion/src/server/mod.rs

@@ -1,25 +1,12 @@
-use crate::ServerConfig;
-use failure::Fallible;
-
 #[cfg(test)]
 pub(crate) mod test;
 
+mod config;
 mod local;
 mod remote;
 mod types;
 
+pub use config::ServerConfig;
 pub use local::LocalServer;
 pub use remote::RemoteServer;
 pub use types::*;
-
-/// Create a new server based on the given configuration.
-pub fn from_config(config: ServerConfig) -> Fallible<Box<dyn Server>> {
-    Ok(match config {
-        ServerConfig::Local { server_dir } => Box::new(LocalServer::new(server_dir)?),
-        ServerConfig::Remote {
-            origin,
-            client_key,
-            encryption_secret,
-        } => Box::new(RemoteServer::new(origin, client_key, encryption_secret)),
-    })
-}