Merge command line arguments and `Config`

src/config.rs

+use clap;
 use std::fs::File;
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
     tile_cache_dir: PathBuf,
     sources: Vec<(String, TileSource)>,
     fps: f64,
+    use_network: bool,
+    async: bool,
 }
 
 impl Config {
-    pub fn load() -> Result<Config, String> {
+    pub fn from_arg_matches<'a>(matches: &clap::ArgMatches<'a>) -> Result<Config, String> {
+        let mut config = if let Some(config_path) = matches.value_of_os("config") {
+            Config::from_toml_file(config_path)?
+        } else {
+            Config::find_or_create()?
+        };
+
+        config.merge_arg_matches(matches);
+
+        Ok(config)
+    }
+
+    fn merge_arg_matches<'a>(&mut self, matches: &clap::ArgMatches<'a>) {
+        if let Some(Ok(fps)) = matches.value_of("fps").map(|s| s.parse()) {
+            self.fps = fps;
+        }
+
+        if matches.is_present("offline") {
+            self.use_network = false;
+        }
+
+        if matches.is_present("sync") {
+            self.async = false;
+        }
+    }
+
+    pub fn find_or_create() -> Result<Config, String> {
         if let Ok(xdg_dirs) = xdg::BaseDirectories::with_prefix("deltamap") {
             if let Some(config_path) = xdg_dirs.find_config_file("config.toml") {
                 info!("load config from path {:?}", config_path);
                     }
                 };
 
+                let use_network = {
+                    match table.get("use_network") {
+                        Some(&Value::Boolean(x)) => x,
+                        Some(_) => return Err("use_network has to be a boolean.".to_string()),
+                        None => true,
+                    }
+                };
+
+                let async = {
+                    match table.get("async") {
+                        Some(&Value::Boolean(x)) => x,
+                        Some(_) => return Err("async has to be a boolean.".to_string()),
+                        None => true,
+                    }
+                };
+
                 let sources_table = table.get("tile_sources")
                     .ok_or_else(|| "missing \"tile_sources\" table".to_string())?
                     .as_table()
                         tile_cache_dir: tile_cache_dir,
                         sources: sources_vec,
                         fps: fps,
+                        use_network: use_network,
+                        async: async,
                     }
                 )
             },
     pub fn fps(&self) -> f64 {
         self.fps
     }
+
+    pub fn use_network(&self) -> bool {
+        self.use_network
+    }
+
+    pub fn async(&self) -> bool {
+        self.async
+    }
 }
 
 #[cfg(test)]

src/main.rs

 fn main() {
     env_logger::init();
 
-    let matches = args::parse();
-
-    let config = if let Some(config_path) = matches.value_of_os("config") {
-            config::Config::from_toml_file(config_path).unwrap()
-        } else {
-            config::Config::load().unwrap()
-        };
+    let config = config::Config::from_arg_matches(&args::parse()).unwrap();
 
     let mut sources = TileSources::new(config.tile_sources()).unwrap();
 
             &cx,
             window.get_inner_size().unwrap(),
             move || { proxy.wakeup().unwrap(); },
-            !matches.is_present("offline"),
-            !matches.is_present("sync"),
+            config.use_network(),
+            config.async(),
         )
     };
 
         mouse_pressed: false,
     };
 
-    let fps: f64 = matches.value_of("fps").map(|s| s.parse().unwrap()).unwrap_or_else(|| config.fps());
-    let duration_per_frame = Duration::from_millis((1000.0 / fps - 0.5).max(0.0).floor() as u64);
+    let duration_per_frame = Duration::from_millis((1000.0 / config.fps() - 0.5).max(0.0).floor() as u64);
     info!("milliseconds per frame: {}", dur_to_sec(duration_per_frame) * 1000.0);
 
     // estimated draw duration