remove output from options, improve error messages

Author: snshn

src/core.rs

@@ -63,7 +63,6 @@ pub struct Options {
     pub no_js: bool,
     pub no_metadata: bool,
     pub no_video: bool,
-    pub output: String,
     pub silent: bool,
     pub timeout: u64,
     pub unwrap_noscript: bool,
@@ -102,12 +101,12 @@ const PLAINTEXT_MEDIA_TYPES: &[&str] = &[
 ];
 
 pub fn create_monolithic_document(
-    target: String,
+    source: String,
     options: &Options,
     mut cache: &mut Cache, // TODO: make it Option-al
 ) -> Result<Vec<u8>, MonolithError> {
-    // Check if target was provided
-    if target.len() == 0 {
+    // Check if source was provided
+    if source.len() == 0 {
         return Err(MonolithError::new("no target specified"));
     }
 
@@ -123,7 +122,7 @@ pub fn create_monolithic_document(
 
     let mut use_stdin: bool = false;
 
-    let target_url = match target.as_str() {
+    let target_url = match source.as_str() {
         "-" => {
             // Read from pipe (stdin)
             use_stdin = true;
@@ -150,26 +149,24 @@ pub fn create_monolithic_document(
                             match Url::from_file_path(canonical_path) {
                                 Ok(url) => url,
                                 Err(_) => {
-                                    // eprintln!(
-                                    //     "Could not generate file URL out of given path: {}",
-                                    //     &target
-                                    // );
-                                    return Err(MonolithError::new(
-                                        "could not generate file URL out of given path",
-                                    ));
+                                    return Err(MonolithError::new(&format!(
+                                        "could not generate file URL out of given path \"{}\"",
+                                        &target
+                                    )));
                                 }
                             }
                         }
                         false => {
-                            // eprintln!("Local target is not a file: {}", &target);
-                            return Err(MonolithError::new("local target is not a file"));
+                            return Err(MonolithError::new(&format!(
+                                "local target \"{}\" is not a file",
+                                &target
+                            )));
                         }
                     },
                     false => {
                         // It is not a FS path, now we do what browsers do:
                         // prepend "http://" and hope it points to a website
-                        Url::parse(&format!("http://{hopefully_url}", hopefully_url = &target))
-                            .unwrap()
+                        Url::parse(&format!("http://{}", &target)).unwrap()
                     }
                 }
             }

src/main.rs

@@ -16,11 +16,11 @@ enum Output {
 }
 
 impl Output {
-    fn new(file_path: &str) -> Result<Output, IoError> {
-        if file_path.is_empty() || file_path.eq("-") {
+    fn new(destination: &str) -> Result<Output, IoError> {
+        if destination.is_empty() || destination.eq("-") {
             Ok(Output::Stdout(io::stdout()))
         } else {
-            Ok(Output::File(fs::File::create(file_path)?))
+            Ok(Output::File(fs::File::create(destination)?))
         }
     }
 
@@ -66,7 +66,8 @@ fn main() {
     // Process CLI flags and options
     let mut cookie_file_path: Option<String> = None;
     let mut options: Options = Options::default();
-    let target;
+    let source;
+    let destination;
     {
         let app = App::new(env!("CARGO_PKG_NAME"))
             .version(env!("CARGO_PKG_VERSION"))
@@ -117,7 +118,7 @@ fn main() {
             .get_matches();
 
         // Process the command
-        target = app
+        source = app
             .value_of("target")
             .expect("please set target")
             .to_string();
@@ -145,7 +146,7 @@ fn main() {
         options.no_js = app.is_present("no-js");
         options.insecure = app.is_present("insecure");
         options.no_metadata = app.is_present("no-metadata");
-        options.output = app.value_of("output").unwrap_or("").to_string();
+        destination = app.value_of("output").unwrap_or("").to_string();
         options.silent = app.is_present("silent");
         options.timeout = app
             .value_of("timeout")
@@ -209,10 +210,10 @@ fn main() {
         }
     }
 
-    match create_monolithic_document(target, &options, &mut cache) {
+    match create_monolithic_document(source, &options, &mut cache) {
         Ok(result) => {
             // Define output
-            let mut output = Output::new(&options.output).expect("Could not prepare output");
+            let mut output = Output::new(&destination).expect("Could not prepare output");
 
             // Write result into STDOUT or file
             output.write(&result).expect("Could not write output");

tests/core/options.rs

@@ -24,7 +24,6 @@ mod passing {
         assert_eq!(options.no_js, false);
         assert_eq!(options.insecure, false);
         assert_eq!(options.no_metadata, false);
-        assert_eq!(options.output, "".to_string());
         assert_eq!(options.silent, false);
         assert_eq!(options.timeout, 0);
         assert_eq!(options.user_agent, None);